pyvista API Reference
Full documentation for pyvista (0.48.4)
pyvista.AVSucdReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.AccessorRegistration
Python Library Documentation: class AccessorRegistration in module pyvista.core.utilities.accessor_registry
class AccessorRegistration(builtins.tuple)
| AccessorRegistration(name: ForwardRef('str'), target: ForwardRef('type'), accessor: ForwardRef('type'), source: ForwardRef('str'))
|
| Describe one registered dataset accessor.
|
| Returned by :func:`~pyvista.registered_accessors`.
|
| .. versionadded:: 0.48.0
|
| Attributes
| ----------
| name : str
| The namespace the accessor is attached under (e.g. ``'meshfix'``).
| target : type
| The PyVista dataset class (or base class) the accessor is
| registered against.
| accessor : type
| The accessor class itself.
| source : str
| Human-readable origin in the form ``'module.qualname'`` — useful
| for debugging which plugin registered a given accessor.
|
| Method resolution order:
| AccessorRegistration
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.AccessorRegistration
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.AccessorRegistration
| Return a nicely formatted representation string
|
| _asdict(self) from collections.AccessorRegistration
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.AccessorRegistration
| Return a new AccessorRegistration object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.AccessorRegistration
| Make a new AccessorRegistration object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, name: ForwardRef('str'), target: ForwardRef('type'), accessor: ForwardRef('type'), source: ForwardRef('str')) from namedtuple_AccessorRegistration.AccessorRegistration
| Create new instance of AccessorRegistration(name, target, accessor, source)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| name
| Alias for field number 0
|
| target
| Alias for field number 1
|
| accessor
| Alias for field number 2
|
| source
| Alias for field number 3
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'accessor': ForwardRef('type'), 'name': ForwardRef(...
|
| __match_args__ = ('name', 'target', 'accessor', 'source')
|
| __orig_bases__ = (<function NamedTuple>,)
|
| _field_defaults = {}
|
| _fields = ('name', 'target', 'accessor', 'source')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
pyvista.AmbiguousDataError
Python Library Documentation: class AmbiguousDataError in module pyvista.core.errors class AmbiguousDataError(builtins.ValueError) | AmbiguousDataError(message='Multiple data available.') -> 'None' | | Exception when data is ambiguous, e.g. multiple active scalars can be set. | | Parameters | ---------- | message : str | Error message. | | Method resolution order: | AmbiguousDataError | builtins.ValueError | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, message='Multiple data available.') -> 'None' | Call the base class constructor with the custom message. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Static methods inherited from builtins.ValueError: | | __new__(*args, **kwargs) class method of builtins.ValueError | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.AnnotatedIntEnum
Python Library Documentation: class AnnotatedIntEnum in module pyvista.core.utilities.misc class AnnotatedIntEnum(builtins.int, enum.Enum) | AnnotatedIntEnum(new_class_name, /, names, *, module=None, qualname=None, type=None, start=1, boundary=None) | | Annotated enum type. | | Method resolution order: | AnnotatedIntEnum | builtins.int | enum.Enum | builtins.object | | Methods defined here: | | __format__(self, format_spec) from enum.Enum | Default object formatter. | | Return str(self) if format_spec is empty. Raise TypeError otherwise. | | __new__(cls, value) from enum.Enum | Create and return a new object. See help(type) for accurate signature. | | __repr__(self) from enum.Enum | Return repr(self). | | ---------------------------------------------------------------------- | Methods inherited from builtins.int: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | True if self else False | | __ceil__(...) | Ceiling of an Integral returns itself. | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floor__(...) | Flooring an Integral returns itself. | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(self, /) | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __round__(...) | Rounding an Integral returns itself. | | Rounding with an ndigits argument also returns an integer. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __sizeof__(self, /) | Returns size in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __trunc__(...) | Truncating an Integral returns itself. | | __xor__(self, value, /) | Return self^value. | | as_integer_ratio(self, /) | Return a pair of integers, whose ratio is equal to the original int. | | The ratio is in lowest terms and has a positive denominator. | | >>> (10).as_integer_ratio() | (10, 1) | >>> (-10).as_integer_ratio() | (-10, 1) | >>> (0).as_integer_ratio() | (0, 1) | | bit_count(self, /) | Number of ones in the binary representation of the absolute value of self. | | Also known as the population count. | | >>> bin(13) | '0b1101' | >>> (13).bit_count() | 3 | | bit_length(self, /) | Number of bits necessary to represent self in binary. | | >>> bin(37) | '0b100101' | >>> (37).bit_length() | 6 | | conjugate(...) | Returns self, the complex conjugate of any int. | | is_integer(self, /) | Returns True. Exists for duck type compatibility with float.is_integer. | | to_bytes(self, /, length=1, byteorder='big', *, signed=False) | Return an array of bytes representing an integer. | | length | Length of bytes object to use. An OverflowError is raised if the | integer is not representable with the given number of bytes. Default | is length 1. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Determines whether two's complement is used to represent the integer. | If signed is False and a negative integer is given, an OverflowError | is raised. | | ---------------------------------------------------------------------- | Class methods inherited from builtins.int: | | from_bytes(bytes, byteorder='big', *, signed=False) | Return the integer represented by the given array of bytes. | | bytes | Holds the array of bytes to convert. The argument must either | support the buffer protocol or be an iterable object producing bytes. | Bytes and bytearray are examples of built-in objects that support the | buffer protocol. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Indicates whether two's complement is used to represent the integer. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.int: | | denominator | the denominator of a rational number in lowest terms | | imag | the imaginary part of a complex number | | numerator | the numerator of a rational number in lowest terms | | real | the real part of a complex number | | ---------------------------------------------------------------------- | Methods inherited from enum.Enum: | | __dir__(self) | Returns public methods and other interesting attributes. | | __init__(self, *args, **kwds) | Initialize self. See help(type(self)) for accurate signature. | | __reduce_ex__(self, proto) | Helper for pickle. | | __str__(self) | Return str(self). | | ---------------------------------------------------------------------- | Data descriptors inherited from enum.Enum: | | name | The name of the Enum member. | | value | The value of the Enum member. | | ---------------------------------------------------------------------- | Static methods inherited from enum.EnumType: | | __contains__(value) | Return True if `value` is in `cls`. | | `value` is in `cls` if: | 1) `value` is a member of `cls`, or | 2) `value` is the value of one of the `cls`'s members. | | __getitem__(name) | Return the member matching `name`. | | __iter__() | Return members in definition order. | | __len__() | Return the number of members (no aliases) | | ---------------------------------------------------------------------- | Readonly properties inherited from enum.EnumType: | | __members__ | Returns a mapping of member name->value. | | This mapping lists all enum members, including aliases. Note that this | is a read-only view of the internal mapping.
pyvista.ArrayLike
Python Library Documentation: _UnionGenericAlias in module typing
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
pyvista.Arrow
Python Library Documentation: function Arrow in module pyvista.core.utilities.geometric_objects
Arrow(start: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0), tip_length: 'float' = 0.25, tip_radius: 'float' = 0.1, tip_resolution: 'int' = 20, shaft_radius: 'float' = 0.05, shaft_resolution: 'int' = 20, scale: "float | Literal['auto'] | None" = 1.0) -> 'PolyData'
Create an arrow.
Parameters
----------
start : sequence[float], default: (0.0, 0.0, 0.0)
Start location in ``[x, y, z]``.
direction : sequence[float], default: (1.0, 0.0, 0.0)
Direction the arrow points to in ``[x, y, z]``.
tip_length : float, default: 0.25
Length of the tip.
tip_radius : float, default: 0.1
Radius of the tip.
tip_resolution : int, default: 20
Number of faces around the tip.
shaft_radius : float, default: 0.05
Radius of the shaft.
shaft_resolution : int, default: 20
Number of faces around the shaft.
scale : float | str, optional
Scale factor of the entire object, defaults to a scale of 1.
``'auto'`` scales to length of direction array.
Returns
-------
pyvista.PolyData
Arrow mesh.
Examples
--------
Plot a default arrow.
>>> import pyvista as pv
>>> mesh = pv.Arrow()
>>> mesh.plot(show_edges=True)
pyvista.ArrowSource
Python Library Documentation: class ArrowSource in module pyvista.core.utilities.geometric_sources
class ArrowSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkArrowSource)
| ArrowSource(*args, **kwargs) -> '_T'
|
| Create a arrow source.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| tip_length : float, default: 0.25
| Length of the tip.
|
| tip_radius : float, default: 0.1
| Radius of the tip.
|
| tip_resolution : int, default: 20
| Number of faces around the tip.
|
| shaft_radius : float, default: 0.05
| Radius of the shaft.
|
| shaft_resolution : int, default: 20
| Number of faces around the shaft.
|
| Method resolution order:
| ArrowSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkArrowSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'ArrowSource', tip_length: 'float' = 0.25, tip_radius: 'float' = 0.1, tip_resolution: 'int' = 20, shaft_radius: 'float' = 0.05, shaft_resolution: 'int' = 20) -> 'None'
| Initialize source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Plane mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| shaft_radius
| Get the radius of the shaft.
|
| Returns
| -------
| int
| The radius of the shaft.
|
| shaft_resolution
| Get the number of faces around the shaft.
|
| Returns
| -------
| int
| The number of faces around the shaft.
|
| tip_length
| Get the length of the tip.
|
| Returns
| -------
| int
| The length of the tip.
|
| tip_radius
| Get the radius of the tip.
|
| Returns
| -------
| int
| The radius of the tip.
|
| tip_resolution
| Get the number of faces around the tip.
|
| Returns
| -------
| int
| The number of faces around the tip.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkArrowSource:
|
| GetArrowOrigin(...)
| GetArrowOrigin(self) -> ArrowOrigins
| C++: virtual ArrowOrigins GetArrowOrigin()
|
| GetArrowOriginAsString(...)
| GetArrowOriginAsString(self) -> str
| C++: std::string GetArrowOriginAsString()
|
| GetInvert(...)
| GetInvert(self) -> bool
| C++: virtual bool GetInvert()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetShaftRadius(...)
| GetShaftRadius(self) -> float
| C++: virtual double GetShaftRadius()
|
| GetShaftRadiusMaxValue(...)
| GetShaftRadiusMaxValue(self) -> float
| C++: virtual double GetShaftRadiusMaxValue()
|
| GetShaftRadiusMinValue(...)
| GetShaftRadiusMinValue(self) -> float
| C++: virtual double GetShaftRadiusMinValue()
|
| GetShaftResolution(...)
| GetShaftResolution(self) -> int
| C++: virtual int GetShaftResolution()
|
| GetShaftResolutionMaxValue(...)
| GetShaftResolutionMaxValue(self) -> int
| C++: virtual int GetShaftResolutionMaxValue()
|
| GetShaftResolutionMinValue(...)
| GetShaftResolutionMinValue(self) -> int
| C++: virtual int GetShaftResolutionMinValue()
|
| GetTipLength(...)
| GetTipLength(self) -> float
| C++: virtual double GetTipLength()
|
| GetTipLengthMaxValue(...)
| GetTipLengthMaxValue(self) -> float
| C++: virtual double GetTipLengthMaxValue()
|
| GetTipLengthMinValue(...)
| GetTipLengthMinValue(self) -> float
| C++: virtual double GetTipLengthMinValue()
|
| GetTipRadius(...)
| GetTipRadius(self) -> float
| C++: virtual double GetTipRadius()
|
| GetTipRadiusMaxValue(...)
| GetTipRadiusMaxValue(self) -> float
| C++: virtual double GetTipRadiusMaxValue()
|
| GetTipRadiusMinValue(...)
| GetTipRadiusMinValue(self) -> float
| C++: virtual double GetTipRadiusMinValue()
|
| GetTipResolution(...)
| GetTipResolution(self) -> int
| C++: virtual int GetTipResolution()
|
| GetTipResolutionMaxValue(...)
| GetTipResolutionMaxValue(self) -> int
| C++: virtual int GetTipResolutionMaxValue()
|
| GetTipResolutionMinValue(...)
| GetTipResolutionMinValue(self) -> int
| C++: virtual int GetTipResolutionMinValue()
|
| InvertOff(...)
| InvertOff(self) -> None
| C++: virtual void InvertOff()
|
| InvertOn(...)
| InvertOn(self) -> None
| C++: virtual void InvertOn()
|
| Inverts the arrow direction. When set to true, base is at (1, 0,
| 0) while the tip is at (0, 0, 0). The default is false, i.e. base
| at (0, 0, 0) and the tip at (1, 0, 0).
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkArrowSource
| C++: vtkArrowSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkArrowSource
| C++: static vtkArrowSource *SafeDownCast(vtkObjectBase *o)
|
| SetArrowOrigin(...)
| SetArrowOrigin(self, _arg:ArrowOrigins) -> None
| C++: virtual void SetArrowOrigin(ArrowOrigins _arg)
|
| Sets and Gets the location used for orienting and scaling the
| arrow. Default is set to Default.
|
| SetArrowOriginToCenter(...)
| SetArrowOriginToCenter(self) -> None
| C++: void SetArrowOriginToCenter()
|
| SetArrowOriginToDefault(...)
| SetArrowOriginToDefault(self) -> None
| C++: void SetArrowOriginToDefault()
|
| SetInvert(...)
| SetInvert(self, _arg:bool) -> None
| C++: virtual void SetInvert(bool _arg)
|
| SetShaftRadius(...)
| SetShaftRadius(self, _arg:float) -> None
| C++: virtual void SetShaftRadius(double _arg)
|
| Set the radius of the shaft. Defaults to 0.03.
|
| SetShaftResolution(...)
| SetShaftResolution(self, _arg:int) -> None
| C++: virtual void SetShaftResolution(int _arg)
|
| Set the resolution of the shaft. Minimum is 3 for a triangular
| shaft.
|
| SetTipLength(...)
| SetTipLength(self, _arg:float) -> None
| C++: virtual void SetTipLength(double _arg)
|
| Set the length, and radius of the tip. They default to 0.35 and
| 0.1
|
| SetTipRadius(...)
| SetTipRadius(self, _arg:float) -> None
| C++: virtual void SetTipRadius(double _arg)
|
| SetTipResolution(...)
| SetTipResolution(self, _arg:int) -> None
| C++: virtual void SetTipResolution(int _arg)
|
| Set the resolution of the tip. The tip behaves the same as a
| cone. Resolution 1 gives a single triangle, 2 gives two crossed
| triangles.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkArrowSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkArrowSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkArrowSource:
|
| __this__
| Pointer to the C++ object.
|
| arrow_origin
| read-write, calls GetArrowOrigin/SetArrowOrigin
|
| invert
| read-write, calls GetInvert/SetInvert
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkArrowSource:
|
| ArrowOrigins = <class 'vtkmodules.vtkFiltersSources.vtkArrowSource.Arr...
|
| __vtkname__ = 'vtkArrowSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.AxesGeometrySource
Python Library Documentation: class AxesGeometrySource in module pyvista.core.utilities.geometric_sources
class AxesGeometrySource(pyvista.core.utilities.misc._NoNewAttrMixin)
| AxesGeometrySource(*args, **kwargs) -> '_T'
|
| Create axes geometry source.
|
| Source for generating fully 3-dimensional axes shaft and tip geometry.
|
| By default, the shafts are cylinders and the tips are cones, though other geometries
| such as spheres and cubes are also supported. The use of an arbitrary dataset
| for the shafts and/or tips is also supported.
|
| Unlike :class:`pyvista.AxesActor`, the output from this source is a
| :class:`pyvista.MultiBlock`, not an actor, and does not support colors or labels.
| The generated axes are "true-to-scale" by default, i.e. a shaft with a
| radius of 0.1 will truly have a radius of 0.1, and the axes may be oriented
| arbitrarily in space (this is not the case for :class:`pyvista.AxesActor`).
|
| Parameters
| ----------
| shaft_type : str | pyvista.DataSet, default: 'cylinder'
| Shaft type for all axes. Can be any of the following:
|
| - ``'cylinder'``
| - ``'sphere'``
| - ``'hemisphere'``
| - ``'cone'``
| - ``'pyramid'``
| - ``'cube'``
| - ``'octahedron'``
|
| Alternatively, any arbitrary 3-dimensional :class:`pyvista.DataSet` may be
| specified. In this case, the dataset must be oriented such that it "points" in
| the positive z direction.
|
| shaft_radius : float | VectorLike[float], default: 0.025
| Radius of the axes shafts.
|
| shaft_length : float | VectorLike[float], default: 0.8
| Length of the shaft for each axis.
|
| tip_type : str | pyvista.DataSet, default: 'cone'
| Tip type for all axes. Can be any of the following:
|
| - ``'cylinder'``
| - ``'sphere'``
| - ``'hemisphere'``
| - ``'cone'``
| - ``'pyramid'``
| - ``'cube'``
| - ``'octahedron'``
|
| Alternatively, any arbitrary 3-dimensional :class:`pyvista.DataSet` may be
| specified. In this case, the dataset must be oriented such that it "points" in
| the positive z direction.
|
| tip_radius : float | VectorLike[float], default: 0.1
| Radius of the axes tips.
|
| tip_length : float | VectorLike[float], default: 0.2
| Length of the tip for each axis.
|
| symmetric : bool, default: False
| Mirror the axes such that they extend to negative values.
|
| symmetric_bounds : bool, default: False
| Make the bounds of the axes symmetric. This option is similar to
| :attr:`symmetric`, except only the bounds are made to be symmetric,
| not the actual geometry. Has no effect if :attr:`symmetric` is ``True``.
|
| Method resolution order:
| AxesGeometrySource
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'AxesGeometrySource', *, shaft_type: 'GeometryTypes | DataSet' = 'cylinder', shaft_radius: 'float | VectorLike[float]' = 0.025, shaft_length: 'float | VectorLike[float]' = 0.8, tip_type: 'GeometryTypes | DataSet' = 'cone', tip_radius: 'float | VectorLike[float]' = 0.1, tip_length: 'float | VectorLike[float]' = 0.2, symmetric: 'bool' = False, symmetric_bounds: 'bool' = False) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self: 'AxesGeometrySource') -> 'str'
| Representation of the axes.
|
| update(self: 'AxesGeometrySource') -> 'None'
| Update the output of the source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output of the source.
|
| The output is a :class:`pyvista.MultiBlock` with six blocks: one for each part
| of the axes. The blocks are ordered by shafts first then tips, and in x-y-z order.
| Specifically, they are named as follows:
|
| (``'x_shaft'``, ``'y_shaft'``, ``'z_shaft'``, ``'x_tip'``, ``'y_tip'``, ``'z_tip'``)
|
| The source is automatically updated by :meth:`update` prior to returning
| the output.
|
| Returns
| -------
| pyvista.MultiBlock
| Composite mesh with separate shaft and tip datasets.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| shaft_length
| Length of the shaft for each axis.
|
| Value must be non-negative.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> axes_geometry_source = pv.AxesGeometrySource()
| >>> axes_geometry_source.shaft_length
| (0.8, 0.8, 0.8)
| >>> axes_geometry_source.shaft_length = 0.7
| >>> axes_geometry_source.shaft_length
| (0.7, 0.7, 0.7)
| >>> axes_geometry_source.shaft_length = (1.0, 0.9, 0.5)
| >>> axes_geometry_source.shaft_length
| (1.0, 0.9, 0.5)
|
| shaft_radius
| Radius of the axes shafts.
|
| Value must be non-negative.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> axes_geometry_source = pv.AxesGeometrySource()
| >>> axes_geometry_source.shaft_radius
| (0.025, 0.025, 0.025)
| >>> axes_geometry_source.shaft_radius = 0.05
| >>> axes_geometry_source.shaft_radius
| (0.05, 0.05, 0.05)
|
| shaft_type
| Shaft type for all axes.
|
| Must be a string, e.g. ``'cylinder'`` or ``'cube'`` or any other supported
| geometry. Alternatively, any arbitrary 3-dimensional :class:`pyvista.DataSet`
| may also be specified. In this case, the dataset must be oriented such that it
| "points" in the positive z direction.
|
| Examples
| --------
| Show a list of all shaft type options.
|
| >>> import pyvista as pv
| >>> pv.AxesGeometrySource.GEOMETRY_TYPES
| ('cylinder', 'sphere', 'hemisphere', 'cone', 'pyramid', 'cube', 'octahedron')
|
| Show the default shaft type and modify it.
|
| >>> axes_geometry_source = pv.AxesGeometrySource()
| >>> axes_geometry_source.shaft_type
| 'cylinder'
| >>> axes_geometry_source.shaft_type = 'cube'
| >>> axes_geometry_source.shaft_type
| 'cube'
|
| Set the shaft type to any 3-dimensional dataset.
|
| >>> axes_geometry_source.shaft_type = pv.Superquadric()
| >>> axes_geometry_source.shaft_type
| 'custom'
|
| symmetric
| Mirror the axes such that they extend to negative values.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> axes_geometry_source = pv.AxesGeometrySource(symmetric=True)
| >>> axes_geometry_source.output.plot()
|
| symmetric_bounds
| Enable or disable symmetry in the axes bounds.
|
| This option is similar to :attr:`~pyvista.AxesGeometrySource.symmetric`, except instead
| of making the axes parts symmetric, only the bounds of the axes are made to be
| symmetric. This is achieved by adding a single invisible cell to each tip
| dataset along each axis to simulate the symmetry. Setting this
| parameter primarily affects camera positioning and is useful if the
| axes are used as a widget, as it allows for the axes to rotate
| about its origin.
|
| Examples
| --------
| Get the symmetric bounds of the axes.
|
| >>> import pyvista as pv
| >>> axes_geometry_source = pv.AxesGeometrySource(symmetric_bounds=True)
| >>> axes_geometry_source.output.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 1.0,
| y_min = -1.0,
| y_max = 1.0,
| z_min = -1.0,
| z_max = 1.0)
|
| >>> axes_geometry_source.output.center
| (0.0, 0.0, 0.0)
|
| Get the asymmetric bounds.
|
| >>> axes_geometry_source.symmetric_bounds = False
| >>> axes_geometry_source.output.bounds
| BoundsTuple(x_min = -0.1,
| x_max = 1.0,
| y_min = -0.1,
| y_max = 1.0,
| z_min = -0.1,
| z_max = 1.0)
|
| >>> axes_geometry_source.output.center
| (0.45, 0.45, 0.45)
|
| Show the difference in camera positioning with and without
| symmetric bounds. Orientation is added for visualization.
|
| Create actors.
|
| >>> axes_sym = pv.AxesAssembly(orientation=(90, 0, 0), symmetric_bounds=True)
| >>> axes_asym = pv.AxesAssembly(orientation=(90, 0, 0), symmetric_bounds=False)
|
| Show multi-window plot.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_text('Symmetric bounds')
| >>> _ = pl.add_actor(axes_sym)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Asymmetric bounds')
| >>> _ = pl.add_actor(axes_asym)
| >>> pl.show()
|
| tip_length
| Length of the tip for each axis.
|
| Value must be non-negative.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> axes_geometry_source = pv.AxesGeometrySource()
| >>> axes_geometry_source.tip_length
| (0.2, 0.2, 0.2)
| >>> axes_geometry_source.tip_length = 0.3
| >>> axes_geometry_source.tip_length
| (0.3, 0.3, 0.3)
| >>> axes_geometry_source.tip_length = (0.1, 0.4, 0.2)
| >>> axes_geometry_source.tip_length
| (0.1, 0.4, 0.2)
|
| tip_radius
| Radius of the axes tips.
|
| Value must be non-negative.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> axes_geometry_source = pv.AxesGeometrySource()
| >>> axes_geometry_source.tip_radius
| (0.1, 0.1, 0.1)
| >>> axes_geometry_source.tip_radius = 0.2
| >>> axes_geometry_source.tip_radius
| (0.2, 0.2, 0.2)
|
| tip_type
| Tip type for all axes.
|
| Must be a string, e.g. ``'cone'`` or ``'sphere'`` or any other supported
| geometry. Alternatively, any arbitrary 3-dimensional :class:`pyvista.DataSet`
| may also be specified. In this case, the dataset must be oriented such that it
| "points" in the positive z direction.
|
| Examples
| --------
| Show a list of all shaft type options.
|
| >>> import pyvista as pv
| >>> pv.AxesGeometrySource.GEOMETRY_TYPES
| ('cylinder', 'sphere', 'hemisphere', 'cone', 'pyramid', 'cube', 'octahedron')
|
| Show the default tip type and modify it.
|
| >>> axes_geometry_source = pv.AxesGeometrySource()
| >>> axes_geometry_source.tip_type
| 'cone'
| >>> axes_geometry_source.tip_type = 'sphere'
| >>> axes_geometry_source.tip_type
| 'sphere'
|
| Set the tip type to any 3-dimensional dataset.
|
| >>> axes_geometry_source.tip_type = pv.Text3D('O')
| >>> axes_geometry_source.tip_type
| 'custom'
|
| >>> axes_geometry_source.output.plot(cpos='xy')
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| GEOMETRY_TYPES = ('cylinder', 'sphere', 'hemisphere', 'cone', 'pyramid...
|
| GeometryTypes = typing.Literal['cylinder', 'sphere', 'hemisphere', 'co...
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'GEOMETRY_TYPES': 'ClassVar[tuple[str]]'}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
pyvista.BMPReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.BMPWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.BUILDING_GALLERY
Python Library Documentation: bool object class bool(int) | bool(x) -> bool | | Returns True when the argument x is true, False otherwise. | The builtins True and False are the only two instances of the class bool. | The class bool is a subclass of the class int, and cannot be subclassed. | | Method resolution order: | bool | int | object | | Methods defined here: | | __and__(self, value, /) | Return self&value. | | __invert__(self, /) | ~self | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __repr__(self, /) | Return repr(self). | | __ror__(self, value, /) | Return value|self. | | __rxor__(self, value, /) | Return value^self. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from int: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | True if self else False | | __ceil__(...) | Ceiling of an Integral returns itself. | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floor__(...) | Flooring an Integral returns itself. | | __floordiv__(self, value, /) | Return self//value. | | __format__(self, format_spec, /) | Convert to a string according to format_spec. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(self, /) | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __round__(...) | Rounding an Integral returns itself. | | Rounding with an ndigits argument also returns an integer. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __sizeof__(self, /) | Returns size in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __trunc__(...) | Truncating an Integral returns itself. | | as_integer_ratio(self, /) | Return a pair of integers, whose ratio is equal to the original int. | | The ratio is in lowest terms and has a positive denominator. | | >>> (10).as_integer_ratio() | (10, 1) | >>> (-10).as_integer_ratio() | (-10, 1) | >>> (0).as_integer_ratio() | (0, 1) | | bit_count(self, /) | Number of ones in the binary representation of the absolute value of self. | | Also known as the population count. | | >>> bin(13) | '0b1101' | >>> (13).bit_count() | 3 | | bit_length(self, /) | Number of bits necessary to represent self in binary. | | >>> bin(37) | '0b100101' | >>> (37).bit_length() | 6 | | conjugate(...) | Returns self, the complex conjugate of any int. | | is_integer(self, /) | Returns True. Exists for duck type compatibility with float.is_integer. | | to_bytes(self, /, length=1, byteorder='big', *, signed=False) | Return an array of bytes representing an integer. | | length | Length of bytes object to use. An OverflowError is raised if the | integer is not representable with the given number of bytes. Default | is length 1. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Determines whether two's complement is used to represent the integer. | If signed is False and a negative integer is given, an OverflowError | is raised. | | ---------------------------------------------------------------------- | Class methods inherited from int: | | from_bytes(bytes, byteorder='big', *, signed=False) | Return the integer represented by the given array of bytes. | | bytes | Holds the array of bytes to convert. The argument must either | support the buffer protocol or be an iterable object producing bytes. | Bytes and bytearray are examples of built-in objects that support the | buffer protocol. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Indicates whether two's complement is used to represent the integer. | | ---------------------------------------------------------------------- | Data descriptors inherited from int: | | denominator | the denominator of a rational number in lowest terms | | imag | the imaginary part of a complex number | | numerator | the numerator of a rational number in lowest terms | | real | the real part of a complex number
pyvista.BYUReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.BaseReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.BaseWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.BinaryMarchingCubesReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.BoundsTuple
Python Library Documentation: class BoundsTuple in module pyvista.core._typing_core._aliases
class BoundsTuple(builtins.tuple)
| BoundsTuple(x_min: ForwardRef('float'), x_max: ForwardRef('float'), y_min: ForwardRef('float'), y_max: ForwardRef('float'), z_min: ForwardRef('float'), z_max: ForwardRef('float'))
|
| Tuple of six values representing 3D bounds.
|
| Has the form ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Method resolution order:
| BoundsTuple
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.BoundsTuple
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| _asdict(self) from collections.BoundsTuple
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.BoundsTuple
| Return a new BoundsTuple object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.BoundsTuple
| Make a new BoundsTuple object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, x_min: ForwardRef('float'), x_max: ForwardRef('float'), y_min: ForwardRef('float'), y_max: ForwardRef('float'), z_min: ForwardRef('float'), z_max: ForwardRef('float')) from namedtuple_BoundsTuple.BoundsTuple
| Create new instance of BoundsTuple(x_min, x_max, y_min, y_max, z_min, z_max)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| x_min
| Alias for field number 0
|
| x_max
| Alias for field number 1
|
| y_min
| Alias for field number 2
|
| y_max
| Alias for field number 3
|
| z_min
| Alias for field number 4
|
| z_max
| Alias for field number 5
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'x_max': ForwardRef('float'), 'x_min': ForwardRef('...
|
| __match_args__ = ('x_min', 'x_max', 'y_min', 'y_max', 'z_min', 'z_max'...
|
| __orig_bases__ = (<function NamedTuple>,)
|
| _field_defaults = {}
|
| _fields = ('x_min', 'x_max', 'y_min', 'y_max', 'z_min', 'z_max')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
pyvista.Box
Python Library Documentation: function Box in module pyvista.core.utilities.geometric_objects
Box(bounds: 'VectorLike[float]' = (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0), level: 'int | VectorLike[int]' = 0, quads: 'bool' = True) -> 'PolyData'
Create a box with solid faces for the given bounds.
Parameters
----------
bounds : sequence[float], default: (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0)
Specify the bounding box of the cube.
``(x_min, x_max, y_min, y_max, z_min, z_max)``.
level : int | VectorLike[int], default: 0
Level of subdivision of the faces.
.. note::
The algorithm is not optimized when a 3 length vector is given.
.. versionadded:: 0.47
Enable specifying different values for x, y and z directions.
quads : bool, default: True
Flag to tell the source to generate either a quad or two
triangle for a set of four points.
Returns
-------
pyvista.PolyData
Mesh of the box.
Examples
--------
Create a box with subdivision ``level=2``.
>>> import pyvista as pv
>>> mesh = pv.Box(level=2)
>>> mesh.plot(show_edges=True)
Set the level separately for each axis.
>>> mesh = pv.Box(level=[1, 2, 3])
>>> mesh.plot(show_edges=True)
pyvista.BoxSource
Python Library Documentation: class BoxSource in module pyvista.core.utilities.geometric_sources
class BoxSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource)
| BoxSource(*args, **kwargs) -> '_T'
|
| Create a box source.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| bounds : sequence[float], default: (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0)
| Specify the bounds of the box.
| ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| level : int, default: 0
| Level of subdivision of the faces.
|
| quads : bool, default: True
| Flag to tell the source to generate either a quad or two
| triangle for a set of four points.
|
| Method resolution order:
| BoxSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'BoxSource', bounds: 'VectorLike[float]' = (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0), level: 'int' = 0, quads: 'bool' = True) -> 'None'
| Initialize source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Plane mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| bounds
| Return or set the bounds of the box.
|
| level
| Get level of subdivision of the faces.
|
| Returns
| -------
| int
| Level of subdivision of the faces.
|
| quads
| Flag to tell the source to generate a quad or two triangle for a set of four points.
|
| Returns
| -------
| bool
| Flag to tell the source to generate either a quad or two
| triangle for a set of four points.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource:
|
| DuplicateSharedPointsOff(...)
| DuplicateSharedPointsOff(self) -> None
| C++: virtual void DuplicateSharedPointsOff()
|
| DuplicateSharedPointsOn(...)
| DuplicateSharedPointsOn(self) -> None
| C++: virtual void DuplicateSharedPointsOn()
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: virtual double *GetBounds()
|
| Bounds of the box in world coordinates. This a 6-uple of
| xmin,xmax,ymin, ymax,zmin and zmax. Initial value is
| (-0.5,0.5,-0.5,0.5,-0.5,0.5), bounds of a cube of length 1
| centered at (0,0,0). Bounds are defined such that xmin<=xmax,
| ymin<=ymax and zmin<zmax.
| \post xmin<=xmax && ymin<=ymax && zmin<zmax
|
| GetDuplicateSharedPoints(...)
| GetDuplicateSharedPoints(self) -> int
| C++: virtual vtkTypeBool GetDuplicateSharedPoints()
|
| GetLevel(...)
| GetLevel(self) -> int
| C++: virtual int GetLevel()
|
| Level of subdivision of the faces. Initial value is 0.
| \post positive_level: level>=0
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetQuads(...)
| GetQuads(self) -> int
| C++: virtual vtkTypeBool GetQuads()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkTessellatedBoxSource
| C++: vtkTessellatedBoxSource *NewInstance()
|
| QuadsOff(...)
| QuadsOff(self) -> None
| C++: virtual void QuadsOff()
|
| QuadsOn(...)
| QuadsOn(self) -> None
| C++: virtual void QuadsOn()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkTessellatedBoxSource
| C++: static vtkTessellatedBoxSource *SafeDownCast(
| vtkObjectBase *o)
|
| SetBounds(...)
| SetBounds(self, _arg1:float, _arg2:float, _arg3:float,
| _arg4:float, _arg5:float, _arg6:float) -> None
| C++: virtual void SetBounds(double _arg1, double _arg2,
| double _arg3, double _arg4, double _arg5, double _arg6)
| SetBounds(self, _arg:(float, float, float, float, float, float))
| -> None
| C++: virtual void SetBounds(const double _arg[6])
|
| Set the bounds of the box. See GetBounds() for a detail
| description.
| \pre xmin<=xmax && ymin<=ymax && zmin<zmax
|
| SetDuplicateSharedPoints(...)
| SetDuplicateSharedPoints(self, _arg:int) -> None
| C++: virtual void SetDuplicateSharedPoints(vtkTypeBool _arg)
|
| Flag to tell the source to duplicate points shared between faces
| (vertices of the box and internal edge points). Initial value is
| false. Implementation note: duplicating points is an easier
| method to implement than a minimal number of points.
|
| SetLevel(...)
| SetLevel(self, _arg:int) -> None
| C++: virtual void SetLevel(int _arg)
|
| Set the level of subdivision of the faces.
| \pre positive_level: level>=0
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetQuads(...)
| SetQuads(self, _arg:int) -> None
| C++: virtual void SetQuads(vtkTypeBool _arg)
|
| Flag to tell the source to generate either a quad or two triangle
| for a set of four points. Initial value is false (generate
| triangles).
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource:
|
| __this__
| Pointer to the C++ object.
|
| duplicate_shared_points
| read-write, calls GetDuplicateSharedPoints/SetDuplicateSharedPoints
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource:
|
| __vtkname__ = 'vtkTessellatedBoxSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.CGNSReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.Capsule
Python Library Documentation: function Capsule in module pyvista.core.utilities.geometric_objects
Capsule(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0), radius: 'float' = 0.5, cylinder_length: 'float' = 1.0, resolution: 'int' = 30) -> 'PolyData'
Create the surface of a capsule.
.. warning::
:func:`pyvista.Capsule` function rotates the capsule :class:`pyvista.PolyData`
in its own way. It rotates the output 90 degrees in z-axis, translates and
orients the mesh to a new ``center`` and ``direction``.
.. note::
A class:`pyvista.CylinderSource` is used to generate the capsule mesh. For vtk
versions below 9.3, a separate ``pyvista.CapsuleSource`` class is used instead.
The mesh geometries are similar but not identical.
.. versionadded:: 0.44.0
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Location of the centroid in ``[x, y, z]``.
direction : sequence[float], default: (1.0, 0.0, 0.0)
Direction the capsule points to in ``[x, y, z]``.
radius : float, default: 0.5
Radius of the capsule.
cylinder_length : float, default: 1.0
Cylinder length of the capsule.
resolution : int, default: 30
Number of points on the circular face of the cylinder.
Returns
-------
pyvista.PolyData
Capsule surface.
See Also
--------
pyvista.Cylinder
Examples
--------
Create a capsule using default parameters.
>>> import pyvista as pv
>>> capsule = pv.Capsule()
>>> capsule.plot(show_edges=True)
pyvista.Cell
Python Library Documentation: class Cell in module pyvista.core.cell
class Cell(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.dataobject.DataObject, vtkmodules.vtkCommonDataModel.vtkGenericCell)
| Cell(*args, **kwargs) -> '_T'
|
| Wrapping of :vtk:`vtkCell`.
|
| This class provides the capability to access a given cell topology and can
| be useful when walking through a cell's individual faces or investigating
| cell properties.
|
| Parameters
| ----------
| vtk_cell : :vtk:`vtkCell`, optional
| The vtk object to wrap as Cell, that must be of :vtk:`vtkCell` type.
|
| cell_type : int, optional
| VTK cell type. Determined from ``vtk_cell`` if not input.
|
| deep : bool, default: False
| Perform a deep copy of the original cell.
|
| See Also
| --------
| pyvista.CellType
|
| Notes
| -----
| Accessing individual cells from a :class:`pyvista.DataSet` using this class
| will be much slower than accessing bulk data from the
| :attr:`pyvista.PolyData.faces` or :attr:`pyvista.UnstructuredGrid.cells` attributes.
|
| Also note that the cell object is a deep copy of the original cell and
| is unassociated with the original cell. Changing any data of
| that cell (for example, :attr:`pyvista.Cell.points`) will not change the original dataset.
|
| Examples
| --------
| Get the 0-th cell from a :class:`pyvista.PolyData`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> cell = mesh.get_cell(0)
| >>> cell # doctest: +SKIP
| Cell (0x7fa760075a10)
| Type: <CellType.TRIANGLE: 5>
| Linear: True
| Dimension: 2
| N Points: 3
| N Faces: 0
| N Edges: 3
| X Bounds: -5.406e-02, -5.551e-17
| Y Bounds: 0.000e+00, 1.124e-02
| Z Bounds: -5.000e-01, -4.971e-01
|
| Get the 0-th cell from a :class:`pyvista.UnstructuredGrid`.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> cell = mesh.get_cell(0)
| >>> cell # doctest: +SKIP
| Cell (0x7fdc71a3c210)
| Type: <CellType.HEXAHEDRON: 12>
| Linear: True
| Dimension: 3
| N Points: 8
| N Faces: 6
| N Edges: 12
| X Bounds: 0.000e+00, 5.000e-01
| Y Bounds: 0.000e+00, 5.000e-01
| Z Bounds: 0.000e+00, 5.000e-01
|
| Method resolution order:
| Cell
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkGenericCell
| vtkmodules.vtkCommonDataModel.vtkCell
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'Self', vtk_cell: '_vtk.vtkCell | None' = None, cell_type: 'CellType | None' = None, deep: 'bool' = False) -> 'None'
| Initialize the cell.
|
| __repr__(self: 'Self') -> 'str'
| Return the object representation.
|
| __str__(self: 'Self') -> 'str'
| Return the object string representation.
|
| cast_to_polydata(self: 'Self') -> 'PolyData'
| Cast this cell to PolyData.
|
| Can only be used for 0D, 1D, or 2D cells.
|
| Returns
| -------
| pyvista.PolyData
| This cell cast to a :class:`pyvista.PolyData`.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_sphere()
| >>> cell = mesh.get_cell(0)
| >>> grid = cell.cast_to_polydata()
| >>> grid # doctest: +SKIP
| PolyData (0x7f09ae437b80)
| N Cells: 1
| N Points: 3
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+01
| Y Bounds: 0.000e+00, 2.500e+01
| Z Bounds: -1.270e+02, -1.250e+02
| N Arrays: 0
|
| cast_to_unstructured_grid(self: 'Self') -> 'UnstructuredGrid'
| Cast this cell to an unstructured grid.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| This cell cast to a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> cell = mesh.get_cell(0)
| >>> grid = cell.cast_to_unstructured_grid()
| >>> grid # doctest: +SKIP
| UnstructuredGrid (0x7f9383619540)
| N Cells: 1
| N Points: 8
| X Bounds: 0.000e+00, 5.000e-01
| Y Bounds: 0.000e+00, 5.000e-01
| Z Bounds: 0.000e+00, 5.000e-01
| N Arrays: 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the cell.
|
| Parameters
| ----------
| deep : bool, optional
| When ``True`` makes a full copy of the cell. When ``False``,
| performs a shallow copy where the new cell still references the
| original cell.
|
| Returns
| -------
| pyvista.Cell
| Deep or shallow copy of the cell.
|
| Examples
| --------
| Create a deep copy of the cell and demonstrate it is deep.
|
| >>> from pyvista.examples.cells import Tetrahedron
| >>> mesh = Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> deep_cell = cell.copy(deep=True)
| >>> deep_cell.points[:] = 0
| >>> cell != deep_cell
| True
|
| Create a shallow copy of the cell and demonstrate it is shallow.
|
| >>> shallow_cell = cell.copy(deep=False)
| >>> shallow_cell.points[:] = 0
| >>> cell == shallow_cell
| True
|
| get_edge(self: 'Self', index: 'int') -> 'Cell'
| Get the i-th edge composing the cell.
|
| Parameters
| ----------
| index : int
| Edge ID.
|
| Returns
| -------
| pyvista.Cell
| Edge given by ``index``.
|
| Examples
| --------
| Extract a single edge from a face and output the IDs of the edge
| points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> cell = mesh.get_cell(0)
| >>> edge = cell.get_edge(0)
| >>> edge.point_ids
| [2, 30]
|
| get_face(self: 'Self', index: 'int') -> 'Cell'
| Get the i-th face composing the cell.
|
| Parameters
| ----------
| index : int
| Face ID.
|
| Returns
| -------
| pyvista.Cell
| Face given by ``index``.
|
| Examples
| --------
| Return the face IDs composing the first face of an example tetrahedron.
|
| >>> from pyvista.examples.cells import Tetrahedron
| >>> mesh = Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> face = cell.get_face(0)
| >>> face.point_ids
| [0, 1, 3]
|
| plot(self: 'Self', **kwargs) -> 'None'
| Plot this cell.
|
| Parameters
| ----------
| **kwargs : dict, optional
| See :func:`pyvista.plot` for a description of the optional keyword
| arguments.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> cell = mesh.get_cell(0)
| >>> cell.plot()
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| bounds
| Get the cell bounds in ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| BoundsTuple
| The cell bounds in ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.05405950918793678,
| y_min = 0.0,
| y_max = 0.011239604093134403,
| z_min = 0.49706897139549255,
| z_max = 0.5)
|
| center
| Get the center of the cell.
|
| Uses parametric coordinate center to determine x-y-z center.
|
| Returns
| -------
| tuple[float, float, float]
| The center of the cell.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).center
| (0.03564589594801267, 0.0037465346977114677, 0.49804598093032837)
|
| dimension
| Return the cell dimension.
|
| This returns the dimensionality of the cell. For example, 1 for an edge,
| 2 for a triangle, and 3 for a tetrahedron.
|
| See Also
| --------
| pyvista.CellType.dimension
|
| Returns
| -------
| int
| The cell dimension.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).dimension
| 2
|
| edges
| Return a list of edges composing the cell.
|
| Returns
| -------
| list[Cell]
| A list of edges composing the cell.
|
| Examples
| --------
| >>> from pyvista.examples.cells import Hexahedron
| >>> mesh = Hexahedron()
| >>> cell = mesh.get_cell(0)
| >>> edges = cell.edges
| >>> len(edges)
| 12
|
| faces
| Return a list of faces composing the cell.
|
| Returns
| -------
| list[Cell]
| A list of faces composing the cell.
|
| Examples
| --------
| >>> from pyvista.examples.cells import Tetrahedron
| >>> mesh = Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> faces = cell.faces
| >>> len(faces)
| 4
|
| is_linear
| Return if the cell is linear.
|
| See Also
| --------
| pyvista.CellType.is_linear
|
| Returns
| -------
| bool
| If the cell is linear.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).is_linear
| True
|
| n_edges
| Get the number of edges composing the cell.
|
| See Also
| --------
| pyvista.CellType.n_edges
|
| Returns
| -------
| int
| The number of edges composing the cell.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).n_edges
| 3
|
| n_faces
| Get the number of faces composing the cell.
|
| See Also
| --------
| pyvista.CellType.n_faces
|
| Returns
| -------
| int
| The number of faces.
|
| Examples
| --------
| >>> from pyvista.examples.cells import Tetrahedron
| >>> mesh = Tetrahedron()
| >>> mesh.get_cell(0).n_faces
| 4
|
| n_points
| Get the number of points composing the cell.
|
| See Also
| --------
| pyvista.CellType.n_points
|
| Returns
| -------
| int
| The number of points.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).n_points
| 3
|
| point_ids
| Get the point IDs composing the cell.
|
| Returns
| -------
| list[int]
| The point IDs composing the cell.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).point_ids
| [2, 30, 0]
|
| points
| Get the point coordinates of the cell.
|
| Returns
| -------
| np.ndarray
| The point coordinates of the cell.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).points
| array([[0.05405951, 0. , 0.49706897],
| [0.05287818, 0.0112396 , 0.49706897],
| [0. , 0. , 0.5 ]])
|
| type
| Get the cell type from the enum :class:`pyvista.CellType`.
|
| Returns
| -------
| pyvista.CellType
| Type of cell.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).type
| <CellType.TRIANGLE: 5>
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'get_data_range', 'is_empty'})
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_meta_from(self: 'Self', *args, **kwargs) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Intended to be overridden by subclasses.
|
| Parameters
| ----------
| *args : tuple
| Positional arguments.
|
| **kwargs : dict, optional
| Keyword arguments.
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| get_data_range(self: 'Self', name: 'str | None', preference: 'FieldAssociation | str') -> 'tuple[float, float]'
| Get the non-NaN min and max of a named array.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| is_empty
| Return ``True`` if the object is empty.
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkGenericCell:
|
| CellBoundary(...)
| CellBoundary(self, subId:int, pcoords:(float, float, float),
| pts:vtkIdList) -> int
| C++: int CellBoundary(int subId, const double pcoords[3],
| vtkIdList *pts) override;
|
| Given parametric coordinates of a point, return the closest cell
| boundary, and whether the point is inside or outside of the cell.
| The cell boundary is defined by a list of points (pts) that
| specify a face (3D cell), edge (2D cell), or vertex (1D cell). If
| the return value of the method is != 0, then the point is inside
| the cell.
|
| Clip(...)
| Clip(self, value:float, cellScalars:vtkDataArray,
| locator:vtkIncrementalPointLocator, connectivity:vtkCellArray,
| inPd:vtkPointData, outPd:vtkPointData, inCd:vtkCellData,
| cellId:int, outCd:vtkCellData, insideOut:int) -> None
| C++: void Clip(double value, vtkDataArray *cellScalars,
| vtkIncrementalPointLocator *locator,
| vtkCellArray *connectivity, vtkPointData *inPd,
| vtkPointData *outPd, vtkCellData *inCd, vtkIdType cellId,
| vtkCellData *outCd, int insideOut) override;
|
| Cut (or clip) the cell based on the input cellScalars and the
| specified value. The output of the clip operation will be one or
| more cells of the same topological dimension as the original
| cell. The flag insideOut controls what part of the cell is
| considered inside - normally cell points whose scalar value is
| greater than "value" are considered inside. If insideOut is on,
| this is reversed. Also, if the output cell data is non-nullptr,
| the cell data from the clipped cell is passed to the generated
| contouring primitives. (Note: the CopyAllocate() method must be
| invoked on both the output cell and point data. The cellId refers
| to the cell from which the cell data is copied.)
|
| Contour(...)
| Contour(self, value:float, cellScalars:vtkDataArray,
| locator:vtkIncrementalPointLocator, verts:vtkCellArray,
| lines:vtkCellArray, polys:vtkCellArray, inPd:vtkPointData,
| outPd:vtkPointData, inCd:vtkCellData, cellId:int,
| outCd:vtkCellData) -> None
| C++: void Contour(double value, vtkDataArray *cellScalars,
| vtkIncrementalPointLocator *locator, vtkCellArray *verts,
| vtkCellArray *lines, vtkCellArray *polys, vtkPointData *inPd,
| vtkPointData *outPd, vtkCellData *inCd, vtkIdType cellId,
| vtkCellData *outCd) override;
|
| Generate contouring primitives. The scalar list cellScalars are
| scalar values at each cell point. The point locator is
| essentially a points list that merges points as they are inserted
| (i.e., prevents duplicates). Contouring primitives can be
| vertices, lines, or polygons. It is possible to interpolate point
| data along the edge by providing input and output point data - if
| outPd is nullptr, then no interpolation is performed. Also, if
| the output cell data is non-nullptr, the cell data from the
| contoured cell is passed to the generated contouring primitives.
| (Note: the CopyAllocate() method must be invoked on both the
| output cell and point data. The cellId refers to the cell from
| which the cell data is copied.)
|
| DeepCopy(...)
| DeepCopy(self, c:vtkCell) -> None
| C++: void DeepCopy(vtkCell *c) override;
|
| Copy this cell by completely copying internal data structures.
| This is slower but safer than ShallowCopy().
|
| Derivatives(...)
| Derivatives(self, subId:int, pcoords:(float, float, float),
| values:(float, ...), dim:int, derivs:[float, ...]) -> None
| C++: void Derivatives(int subId, const double pcoords[3],
| const double *values, int dim, double *derivs) override;
|
| Compute derivatives given cell subId and parametric coordinates.
| The values array is a series of data value(s) at the cell points.
| There is a one-to-one correspondence between cell point and data
| value(s). Dim is the number of data values per cell point. Derivs
| are derivatives in the x-y-z coordinate directions for each data
| value. Thus, if computing derivatives for a scalar function in a
| hexahedron, dim=1, 8 values are supplied, and 3 deriv values are
| returned (i.e., derivatives in x-y-z directions). On the other
| hand, if computing derivatives of velocity (vx,vy,vz) dim=3, 24
| values are supplied ((vx,vy,vz)1, (vx,vy,vz)2, ....()8), and 9
| deriv values are returned ((d(vx)/dx),(d(vx)/dy),(d(vx)/dz),
| (d(vy)/dx),(d(vy)/dy), (d(vy)/dz),
| (d(vz)/dx),(d(vz)/dy),(d(vz)/dz)).
|
| EvaluateLocation(...)
| EvaluateLocation(self, subId:int, pcoords:(float, float, float),
| x:[float, float, float], weights:[float, ...]) -> None
| C++: void EvaluateLocation(int &subId, const double pcoords[3],
| double x[3], double *weights) override;
|
| Determine global coordinate (x[3]) from subId and parametric
| coordinates. Also returns interpolation weights. (The number of
| weights is equal to the number of points in the cell.)
|
| EvaluatePosition(...)
| EvaluatePosition(self, x:(float, float, float),
| closestPoint:[float, float, float], subId:int, pcoords:[float,
| float, float], dist2:float, weights:[float, ...]) -> int
| C++: int EvaluatePosition(const double x[3],
| double closestPoint[3], int &subId, double pcoords[3],
| double &dist2, double weights[]) override;
|
| Given a point x[3] return inside(=1), outside(=0) cell, or (-1)
| computational problem encountered; evaluate parametric
| coordinates, sub-cell id (!=0 only if cell is composite),
| distance squared of point x[3] to cell (in particular, the
| sub-cell indicated), closest point on cell to x[3] (unless
| closestPoint is null, in which case, the closest point and dist2
| are not found), and interpolation weights in cell. (The number of
| weights is equal to the number of points defining the cell).
| Note: on rare occasions a -1 is returned from the method. This
| means that numerical error has occurred and all data returned
| from this method should be ignored. Also, inside/outside is
| determine parametrically. That is, a point is inside if it
| satisfies parametric limits. This can cause problems for cells of
| topological dimension 2 or less, since a point in 3D can project
| onto the cell within parametric limits but be "far" from the
| cell. Thus the value dist2 may be checked to determine true
| in/out.
|
| GetCellDimension(...)
| GetCellDimension(self) -> int
| C++: int GetCellDimension() override;
|
| Return the topological dimensional of the cell (0,1,2, or 3).
|
| GetCellFaces(...)
| GetCellFaces(self) -> vtkCellArray
| C++: vtkCellArray *GetCellFaces()
| GetCellFaces(self, faces:vtkCellArray) -> None
| C++: void GetCellFaces(vtkCellArray *faces)
|
| GetCellType(...)
| GetCellType(self) -> int
| C++: int GetCellType() override;
|
| Return the type of cell.
|
| GetEdge(...)
| GetEdge(self, edgeId:int) -> vtkCell
| C++: vtkCell *GetEdge(int edgeId) override;
|
| Return the edge cell from the edgeId of the cell.
|
| GetFace(...)
| GetFace(self, faceId:int) -> vtkCell
| C++: vtkCell *GetFace(int faceId) override;
|
| Return the face cell from the faceId of the cell. The returned
| vtkCell is an object owned by this instance, hence the return
| value must not be deleted by the caller.
|
| @warning Repeat calls to this function for different face ids
| will change
| the data stored in the internal member object whose pointer is
| returned by this function.
|
| @warning THIS METHOD IS NOT THREAD SAFE.
|
| GetNumberOfEdges(...)
| GetNumberOfEdges(self) -> int
| C++: int GetNumberOfEdges() override;
|
| Return the number of edges in the cell.
|
| GetNumberOfFaces(...)
| GetNumberOfFaces(self) -> int
| C++: int GetNumberOfFaces() override;
|
| Return the number of faces in the cell.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetParametricCenter(...)
| GetParametricCenter(self, pcoords:[float, float, float]) -> int
| C++: int GetParametricCenter(double pcoords[3]) override;
|
| Return center of the cell in parametric coordinates. Note that
| the parametric center is not always located at (0.5,0.5,0.5). The
| return value is the subId that the center is in (if a composite
| cell). If you want the center in x-y-z space, invoke the
| EvaluateLocation() method.
|
| GetParametricCoords(...)
| GetParametricCoords(self) -> (float, ...)
| C++: double *GetParametricCoords() override;
|
| Return a contiguous array of parametric coordinates of the points
| defining this cell. In other words, (px,py,pz, px,py,pz, etc..)
| The coordinates are ordered consistent with the definition of the
| point ordering for the cell. This method returns a non-nullptr
| pointer when the cell is a primary type (i.e., IsPrimaryCell() is
| true). Note that 3D parametric coordinates are returned no matter
| what the topological dimension of the cell.
|
| GetRepresentativeCell(...)
| GetRepresentativeCell(self) -> vtkCell
| C++: vtkCell *GetRepresentativeCell()
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| InstantiateCell(...)
| InstantiateCell(cellType:int) -> vtkCell
| C++: static vtkCell *InstantiateCell(int cellType)
|
| Instantiate a new vtkCell based on it's cell type value
|
| InterpolateDerivs(...)
| InterpolateDerivs(self, pcoords:(float, float, float),
| derivs:[float, ...]) -> None
| C++: void InterpolateDerivs(const double pcoords[3],
| double *derivs) override;
|
| InterpolateFunctions(...)
| InterpolateFunctions(self, pcoords:(float, float, float),
| weights:[float, ...]) -> None
| C++: void InterpolateFunctions(const double pcoords[3],
| double *weights) override;
|
| Compute the interpolation functions/derivatives (aka shape
| functions/derivatives)
|
| IntersectWithLine(...)
| IntersectWithLine(self, p1:(float, float, float), p2:(float,
| float, float), tol:float, t:float, x:[float, float, float],
| pcoords:[float, float, float], subId:int) -> int
| C++: int IntersectWithLine(const double p1[3], const double p2[3],
| double tol, double &t, double x[3], double pcoords[3],
| int &subId) override;
|
| Intersect with a ray. Return parametric coordinates (both line
| and cell) and global intersection coordinates, given ray
| definition p1[3], p2[3] and tolerance tol. The method returns
| non-zero value if intersection occurs. A parametric distance t
| between 0 and 1 along the ray representing the intersection
| point, the point coordinates x[3] in data coordinates and also
| pcoords[3] in parametric coordinates. subId is the index within
| the cell if a composed cell like a triangle strip.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsLinear(...)
| IsLinear(self) -> int
| C++: int IsLinear() override;
|
| Non-linear cells require special treatment beyond the usual cell
| type and connectivity list information. Most cells in VTK are
| implicit cells.
|
| IsPrimaryCell(...)
| IsPrimaryCell(self) -> int
| C++: int IsPrimaryCell() override;
|
| Return whether this cell type has a fixed topology or whether the
| topology varies depending on the data (e.g., vtkConvexPointSet).
| This compares to composite cells that are typically composed of
| primary cells (e.g., a triangle strip composite cell is made up
| of triangle primary cells).
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkGenericCell
| C++: vtkGenericCell *NewInstance()
|
| RequiresExplicitFaceRepresentation(...)
| RequiresExplicitFaceRepresentation(self) -> int
| C++: int RequiresExplicitFaceRepresentation() override;
|
| Determine whether the cell requires explicit face representation,
| and methods for setting and getting the faces (see vtkPolyhedron
| for example usage of these methods).
|
| RequiresInitialization(...)
| RequiresInitialization(self) -> int
| C++: int RequiresInitialization() override;
|
| Some cells require initialization prior to access. For example,
| they may have to triangulate themselves or set up internal data
| structures.
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkGenericCell
| C++: static vtkGenericCell *SafeDownCast(vtkObjectBase *o)
|
| SetCellFaces(...)
| SetCellFaces(self, faces:vtkCellArray) -> int
| C++: int SetCellFaces(vtkCellArray *faces)
|
| SetCellType(...)
| SetCellType(self, cellType:int) -> None
| C++: void SetCellType(int cellType)
|
| This method is used to support the
| vtkDataSet::GetCell(vtkGenericCell *) method. It allows
| vtkGenericCell to act like any cell type by dereferencing an
| internal instance of a concrete cell type. When you set the cell
| type, you are resetting a pointer to an internal cell which is
| then used for computation.
|
| SetCellTypeToBezierCurve(...)
| SetCellTypeToBezierCurve(self) -> None
| C++: void SetCellTypeToBezierCurve()
|
| SetCellTypeToBezierHexahedron(...)
| SetCellTypeToBezierHexahedron(self) -> None
| C++: void SetCellTypeToBezierHexahedron()
|
| SetCellTypeToBezierQuadrilateral(...)
| SetCellTypeToBezierQuadrilateral(self) -> None
| C++: void SetCellTypeToBezierQuadrilateral()
|
| SetCellTypeToBezierTetra(...)
| SetCellTypeToBezierTetra(self) -> None
| C++: void SetCellTypeToBezierTetra()
|
| SetCellTypeToBezierTriangle(...)
| SetCellTypeToBezierTriangle(self) -> None
| C++: void SetCellTypeToBezierTriangle()
|
| SetCellTypeToBezierWedge(...)
| SetCellTypeToBezierWedge(self) -> None
| C++: void SetCellTypeToBezierWedge()
|
| SetCellTypeToBiQuadraticQuad(...)
| SetCellTypeToBiQuadraticQuad(self) -> None
| C++: void SetCellTypeToBiQuadraticQuad()
|
| SetCellTypeToBiQuadraticQuadraticHexahedron(...)
| SetCellTypeToBiQuadraticQuadraticHexahedron(self) -> None
| C++: void SetCellTypeToBiQuadraticQuadraticHexahedron()
|
| SetCellTypeToBiQuadraticQuadraticWedge(...)
| SetCellTypeToBiQuadraticQuadraticWedge(self) -> None
| C++: void SetCellTypeToBiQuadraticQuadraticWedge()
|
| SetCellTypeToBiQuadraticTriangle(...)
| SetCellTypeToBiQuadraticTriangle(self) -> None
| C++: void SetCellTypeToBiQuadraticTriangle()
|
| SetCellTypeToConvexPointSet(...)
| SetCellTypeToConvexPointSet(self) -> None
| C++: void SetCellTypeToConvexPointSet()
|
| SetCellTypeToCubicLine(...)
| SetCellTypeToCubicLine(self) -> None
| C++: void SetCellTypeToCubicLine()
|
| SetCellTypeToEmptyCell(...)
| SetCellTypeToEmptyCell(self) -> None
| C++: void SetCellTypeToEmptyCell()
|
| SetCellTypeToHexagonalPrism(...)
| SetCellTypeToHexagonalPrism(self) -> None
| C++: void SetCellTypeToHexagonalPrism()
|
| SetCellTypeToHexahedron(...)
| SetCellTypeToHexahedron(self) -> None
| C++: void SetCellTypeToHexahedron()
|
| SetCellTypeToLagrangeCurve(...)
| SetCellTypeToLagrangeCurve(self) -> None
| C++: void SetCellTypeToLagrangeCurve()
|
| SetCellTypeToLagrangeHexahedron(...)
| SetCellTypeToLagrangeHexahedron(self) -> None
| C++: void SetCellTypeToLagrangeHexahedron()
|
| SetCellTypeToLagrangeQuadrilateral(...)
| SetCellTypeToLagrangeQuadrilateral(self) -> None
| C++: void SetCellTypeToLagrangeQuadrilateral()
|
| SetCellTypeToLagrangeTetra(...)
| SetCellTypeToLagrangeTetra(self) -> None
| C++: void SetCellTypeToLagrangeTetra()
|
| SetCellTypeToLagrangeTriangle(...)
| SetCellTypeToLagrangeTriangle(self) -> None
| C++: void SetCellTypeToLagrangeTriangle()
|
| SetCellTypeToLagrangeWedge(...)
| SetCellTypeToLagrangeWedge(self) -> None
| C++: void SetCellTypeToLagrangeWedge()
|
| SetCellTypeToLine(...)
| SetCellTypeToLine(self) -> None
| C++: void SetCellTypeToLine()
|
| SetCellTypeToPentagonalPrism(...)
| SetCellTypeToPentagonalPrism(self) -> None
| C++: void SetCellTypeToPentagonalPrism()
|
| SetCellTypeToPixel(...)
| SetCellTypeToPixel(self) -> None
| C++: void SetCellTypeToPixel()
|
| SetCellTypeToPolyLine(...)
| SetCellTypeToPolyLine(self) -> None
| C++: void SetCellTypeToPolyLine()
|
| SetCellTypeToPolyVertex(...)
| SetCellTypeToPolyVertex(self) -> None
| C++: void SetCellTypeToPolyVertex()
|
| SetCellTypeToPolygon(...)
| SetCellTypeToPolygon(self) -> None
| C++: void SetCellTypeToPolygon()
|
| SetCellTypeToPolyhedron(...)
| SetCellTypeToPolyhedron(self) -> None
| C++: void SetCellTypeToPolyhedron()
|
| SetCellTypeToPyramid(...)
| SetCellTypeToPyramid(self) -> None
| C++: void SetCellTypeToPyramid()
|
| SetCellTypeToQuad(...)
| SetCellTypeToQuad(self) -> None
| C++: void SetCellTypeToQuad()
|
| SetCellTypeToQuadraticEdge(...)
| SetCellTypeToQuadraticEdge(self) -> None
| C++: void SetCellTypeToQuadraticEdge()
|
| SetCellTypeToQuadraticHexahedron(...)
| SetCellTypeToQuadraticHexahedron(self) -> None
| C++: void SetCellTypeToQuadraticHexahedron()
|
| SetCellTypeToQuadraticLinearQuad(...)
| SetCellTypeToQuadraticLinearQuad(self) -> None
| C++: void SetCellTypeToQuadraticLinearQuad()
|
| SetCellTypeToQuadraticLinearWedge(...)
| SetCellTypeToQuadraticLinearWedge(self) -> None
| C++: void SetCellTypeToQuadraticLinearWedge()
|
| SetCellTypeToQuadraticPolygon(...)
| SetCellTypeToQuadraticPolygon(self) -> None
| C++: void SetCellTypeToQuadraticPolygon()
|
| SetCellTypeToQuadraticPyramid(...)
| SetCellTypeToQuadraticPyramid(self) -> None
| C++: void SetCellTypeToQuadraticPyramid()
|
| SetCellTypeToQuadraticQuad(...)
| SetCellTypeToQuadraticQuad(self) -> None
| C++: void SetCellTypeToQuadraticQuad()
|
| SetCellTypeToQuadraticTetra(...)
| SetCellTypeToQuadraticTetra(self) -> None
| C++: void SetCellTypeToQuadraticTetra()
|
| SetCellTypeToQuadraticTriangle(...)
| SetCellTypeToQuadraticTriangle(self) -> None
| C++: void SetCellTypeToQuadraticTriangle()
|
| SetCellTypeToQuadraticWedge(...)
| SetCellTypeToQuadraticWedge(self) -> None
| C++: void SetCellTypeToQuadraticWedge()
|
| SetCellTypeToTetra(...)
| SetCellTypeToTetra(self) -> None
| C++: void SetCellTypeToTetra()
|
| SetCellTypeToTriQuadraticHexahedron(...)
| SetCellTypeToTriQuadraticHexahedron(self) -> None
| C++: void SetCellTypeToTriQuadraticHexahedron()
|
| SetCellTypeToTriQuadraticPyramid(...)
| SetCellTypeToTriQuadraticPyramid(self) -> None
| C++: void SetCellTypeToTriQuadraticPyramid()
|
| SetCellTypeToTriangle(...)
| SetCellTypeToTriangle(self) -> None
| C++: void SetCellTypeToTriangle()
|
| SetCellTypeToTriangleStrip(...)
| SetCellTypeToTriangleStrip(self) -> None
| C++: void SetCellTypeToTriangleStrip()
|
| SetCellTypeToVertex(...)
| SetCellTypeToVertex(self) -> None
| C++: void SetCellTypeToVertex()
|
| SetCellTypeToVoxel(...)
| SetCellTypeToVoxel(self) -> None
| C++: void SetCellTypeToVoxel()
|
| SetCellTypeToWedge(...)
| SetCellTypeToWedge(self) -> None
| C++: void SetCellTypeToWedge()
|
| SetPointIds(...)
| SetPointIds(self, pointIds:vtkIdList) -> None
| C++: void SetPointIds(vtkIdList *pointIds)
|
| Set the point ids to use for this cell. This updates the internal
| cell storage as well as the public member variable PointIds.
|
| SetPoints(...)
| SetPoints(self, points:vtkPoints) -> None
| C++: void SetPoints(vtkPoints *points)
|
| Set the points object to use for this cell. This updates the
| internal cell storage as well as the public member variable
| Points.
|
| ShallowCopy(...)
| ShallowCopy(self, c:vtkCell) -> None
| C++: void ShallowCopy(vtkCell *c) override;
|
| See the vtkCell API for descriptions of these methods.
|
| Triangulate(...)
| Triangulate(self, index:int, ptIds:vtkIdList, pts:vtkPoints)
| -> int
| C++: int Triangulate(int index, vtkIdList *ptIds, vtkPoints *pts)
| override;
|
| Generate simplices of proper dimension. If cell is 3D, tetrahedra
| are generated; if 2D triangles; if 1D lines; if 0D points. The
| form of the output is a sequence of points, each n+1 points
| (where n is topological cell dimension) defining a simplex. The
| index is a parameter that controls which triangulation to use (if
| more than one is possible). If numerical degeneracy encountered,
| 0 is returned, otherwise 1 is returned. This method does not
| insert new points: all the points that define the simplices are
| the points that define the cell.
|
| TriangulateIds(...)
| TriangulateIds(self, index:int, ptIds:vtkIdList) -> int
| C++: int TriangulateIds(int index, vtkIdList *ptIds) override;
|
| Generate simplices of proper dimension. If cell is 3D, tetrahedra
| are generated; if 2D triangles; if 1D lines; if 0D points. The
| form of the output is a sequence of points, each n+1 points
| (where n is topological cell dimension) defining a simplex. The
| index is a parameter that controls which triangulation to use (if
| more than one is possible). If numerical degeneracy encountered,
| 0 is returned, otherwise 1 is returned. This method does not
| insert new points: all the points that define the simplices are
| the points that define the cell.
|
| TriangulateLocalIds(...)
| TriangulateLocalIds(self, index:int, ptIds:vtkIdList) -> int
| C++: int TriangulateLocalIds(int index, vtkIdList *ptIds)
| override;
|
| Generate simplices of proper dimension. If cell is 3D, tetrahedra
| are generated; if 2D triangles; if 1D lines; if 0D points. The
| form of the output is a sequence of points, each n+1 points
| (where n is topological cell dimension) defining a simplex. The
| index is a parameter that controls which triangulation to use (if
| more than one is possible). If numerical degeneracy encountered,
| 0 is returned, otherwise 1 is returned. This method does not
| insert new points: all the points that define the simplices are
| the points that define the cell. ptIds are the local indices with
| respect to the cell
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkGenericCell:
|
| __this__
| Pointer to the C++ object.
|
| cell_dimension
| read-only, calls GetCellDimension
|
| cell_faces
| read-only, calls GetCellFaces
|
| cell_type
| read-write, calls GetCellType/SetCellType
|
| number_of_edges
| read-only, calls GetNumberOfEdges
|
| number_of_faces
| read-only, calls GetNumberOfFaces
|
| parametric_coords
| read-only, calls GetParametricCoords
|
| representative_cell
| read-only, calls GetRepresentativeCell
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkGenericCell:
|
| __vtkname__ = 'vtkGenericCell'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkCell:
|
| ComputeBoundingSphere(...)
| ComputeBoundingSphere(self, center:[float, float, float]) -> float
| C++: virtual double ComputeBoundingSphere(double center[3])
|
| Computes the bounding sphere of the cell. If the number of points
| in the cell is lower or equal to 4, an exact bounding sphere is
| computed. If not, Ritter's algorithm is followed. If the input
| sphere has zero points, then each coordinate of center is set to
| NaN, as well as the returned distance.
|
| This method computes the center of the sphere, and returns its
| squared radius.
|
| GetBounds(...)
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
|
| Compute cell bounding box (xmin,xmax,ymin,ymax,zmin,zmax). Copy
| result into user provided array.
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Compute Length squared of cell (i.e., bounding box diagonal
| squared).
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints()
|
| Return the number of points in the cell.
|
| GetParametricDistance(...)
| GetParametricDistance(self, pcoords:(float, float, float))
| -> float
| C++: virtual double GetParametricDistance(const double pcoords[3])
|
| Return the distance of the parametric coordinate provided to the
| cell. If inside the cell, a distance of zero is returned. This is
| used during picking to get the correct cell picked. (The
| tolerance will occasionally allow cells to be picked who are not
| really intersected "inside" the cell.)
|
| GetPointId(...)
| GetPointId(self, ptId:int) -> int
| C++: vtkIdType GetPointId(int ptId)
|
| For cell point i, return the actual point id.
|
| GetPointIds(...)
| GetPointIds(self) -> vtkIdList
| C++: vtkIdList *GetPointIds()
|
| Return the list of point ids defining the cell.
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints()
|
| Get the point coordinates for the cell.
|
| Inflate(...)
| Inflate(self, dist:float) -> int
| C++: virtual int Inflate(double dist)
|
| Inflates the cell. Each edge is displaced following its normal by
| a distance of value `dist`. If dist is negative, then the cell
| shrinks. The resulting cell edges / faces are colinear / coplanar
| to their previous self.
|
| The cell is assumed to be non-degenerate and to have no edge of
| length zero for linear 2D cells. If it is not the case, then no
| inflation is performed. This method needs to be overridden by
| inheriting non-linear / non-2D cells.
|
| \return 1 if inflation was successful, 0 if no inflation was
| performed
|
| IntersectWithCell(...)
| IntersectWithCell(self, other:vtkCell, tol:float=0.0) -> int
| C++: virtual int IntersectWithCell(vtkCell *other, double tol=0.0)
| IntersectWithCell(self, other:vtkCell, boudingBox:vtkBoundingBox,
| otherBoundingBox:vtkBoundingBox, tol:float=0.0) -> int
| C++: virtual int IntersectWithCell(vtkCell *other,
| const vtkBoundingBox &boudingBox,
| const vtkBoundingBox &otherBoundingBox, double tol=0.0)
|
| Intersects with an other cell. Returns 1 if cells intersect, 0
| otherwise. If an exact intersection detection with regards to
| floating point precision is wanted, tol should be disregarded.
| `vtkBoundingBox` are optional parameters which slightly improve
| the speed of the computation if bounding boxes are already
| available to user.
|
| IsExplicitCell(...)
| IsExplicitCell(self) -> int
| C++: virtual int IsExplicitCell()
|
| Explicit cells require additional representational information
| beyond the usual cell type and connectivity list information.
| Most cells in VTK are implicit cells.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkCell:
|
| length2
| read-only, calls GetLength2
|
| number_of_points
| read-only, calls GetNumberOfPoints
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.CellArray
Python Library Documentation: class CellArray in module pyvista.core.cell
class CellArray(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride, vtkmodules.vtkCommonDataModel.vtkCellArray)
| CellArray(*args, **kwargs) -> '_T'
|
| PyVista wrapping of :vtk:`vtkCellArray`.
|
| Provides convenience functions to simplify creating a CellArray from
| a numpy array or list.
|
| Parameters
| ----------
| cells : np.ndarray or list, optional
| Import an array of data with the legacy :vtk:`vtkCellArray` layout, e.g.
| ``{ n0, p0_0, p0_1, ..., p0_n, n1, p1_0, p1_1, ..., p1_n, ... }``
| Where n0 is the number of points in cell 0, and pX_Y is the Y'th
| point in cell X.
|
| Examples
| --------
| Create a cell array containing two triangles from the traditional interleaved format
|
| >>> from pyvista.core.cell import CellArray
| >>> cellarr = CellArray([3, 0, 1, 2, 3, 3, 4, 5])
|
| Create a cell array containing two triangles from separate offsets and connectivity arrays
|
| >>> from pyvista.core.cell import CellArray
| >>> offsets = [0, 3, 6]
| >>> connectivity = [0, 1, 2, 3, 4, 5]
| >>> cellarr = CellArray.from_arrays(offsets, connectivity)
|
| Method resolution order:
| CellArray
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkCellArray
| vtkmodules.vtkCommonDataModel.vtkAbstractCellArray
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'Self', cells: 'CellsLike | None' = None) -> 'None'
| Initialize a :vtk:`vtkCellArray`.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_irregular_cells(cells: 'MatrixLike[int]') -> 'CellArray'
| Construct a ``CellArray`` from a (n_cells, cell_size) array of cell indices.
|
| Parameters
| ----------
| cells : numpy.ndarray or list[list[int]]
| Cell array of shape (n_cells, cell_size) where all cells have the same `cell_size`.
|
| Returns
| -------
| pyvista.CellArray
| Constructed ``CellArray``.
|
| from_regular_cells(cells: 'MatrixLike[int]', deep: 'bool' = False) -> 'CellArray'
| Construct a ``CellArray`` from a (n_cells, cell_size) array of cell indices.
|
| Parameters
| ----------
| cells : numpy.ndarray or list[list[int]]
| Cell array of shape (n_cells, cell_size) where all cells have the same `cell_size`.
|
| deep : bool, default: False
| Whether to deep copy the cell array data into the vtk connectivity array.
|
| Returns
| -------
| pyvista.CellArray
| Constructed ``CellArray``.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| from_arrays(offsets: 'MatrixLike[int]', connectivity: 'MatrixLike[int]', deep: 'bool' = False) -> 'CellArray'
| Construct a CellArray from offsets and connectivity arrays.
|
| Parameters
| ----------
| offsets : MatrixLike[int]
| Offsets array of length `n_cells + 1`.
|
| connectivity : MatrixLike[int]
| Connectivity array.
|
| deep : bool, default: False
| Whether to deep copy the array data into the vtk arrays.
|
| Returns
| -------
| CellArray
| Constructed CellArray.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| connectivity_array
| Return the array with the point ids that define the cells' connectivity.
|
| Returns
| -------
| np.ndarray
| Array with the point ids that define the cells' connectivity.
|
| n_cells
| Return the number of cells.
|
| Returns
| -------
| int
| The number of cells.
|
| offset_array
| Return the array used to store cell offsets.
|
| Returns
| -------
| np.ndarray
| Array used to store cell offsets.
|
| regular_cells
| Return a (n_cells, cell_size)-shaped array of point indices for equal-sized faces.
|
| Returns
| -------
| numpy.ndarray
| Array of face indices of shape (n_cells, cell_size).
|
| Notes
| -----
| This property does not validate that the cells are all
| actually the same size. If they're not, this property may either
| raise a `ValueError` or silently return an incorrect array.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| cells
| Return a numpy array of the cells.
|
| Returns
| -------
| np.ndarray
| A numpy array of the cells.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkCellArray:
|
| Allocate(...)
| Allocate(self, sz:int, ext:int=1000) -> int
| C++: vtkTypeBool Allocate(vtkIdType sz, vtkIdType ext=1000)
|
| Allocate memory.
|
| This currently allocates both the offsets and connectivity arrays
| to sz.
|
| ote It is preferable to use AllocateEstimate(numCells,
| maxCellSize) or AllocateExact(numCells, connectivitySize)
| instead.
|
| AllocateCopy(...)
| AllocateCopy(self, other:vtkCellArray) -> bool
| C++: bool AllocateCopy(vtkCellArray *other)
|
| Pre-allocate memory in internal data structures to match the used
| size of the input vtkCellArray. Does not change the number of
| cells, only the array capacities. Existing data is NOT preserved.
| @param other The vtkCellArray to use as a reference.
| @return True if allocation succeeds.
| @sa Squeeze AllocateEstimate AllocateExact
|
| AllocateEstimate(...)
| AllocateEstimate(self, numCells:int, maxCellSize:int) -> bool
| C++: bool AllocateEstimate(vtkIdType numCells,
| vtkIdType maxCellSize)
|
| Pre-allocate memory in internal data structures. Does not change
| the number of cells, only the array capacities. Existing data is
| NOT preserved.
| @param numCells The number of expected cells in the dataset.
| @param maxCellSize The number of points per cell to allocate
| memory for.
| @return True if allocation succeeds.
| @sa Squeeze AllocateExact AllocateCopy
|
| AllocateExact(...)
| AllocateExact(self, numCells:int, connectivitySize:int) -> bool
| C++: bool AllocateExact(vtkIdType numCells,
| vtkIdType connectivitySize)
|
| Pre-allocate memory in internal data structures. Does not change
| the number of cells, only the array capacities. Existing data is
| NOT preserved.
| @param numCells The number of expected cells in the dataset.
| @param connectivitySize The total number of pointIds stored for
| all cells.
| @return True if allocation succeeds.
| @sa Squeeze AllocateEstimate AllocateCopy
|
| Append(...)
| Append(self, src:vtkCellArray, pointOffset:int=0) -> None
| C++: void Append(vtkCellArray *src, vtkIdType pointOffset=0)
|
| Append cells from src into this. Point ids are offset by
| pointOffset.
|
| AppendLegacyFormat(...)
| AppendLegacyFormat(self, data:vtkIdTypeArray, ptOffset:int=0)
| -> None
| C++: void AppendLegacyFormat(vtkIdTypeArray *data,
| vtkIdType ptOffset=0)
| AppendLegacyFormat(self, data:(int, ...), len:int, ptOffset:int=0)
| -> None
| C++: void AppendLegacyFormat(const vtkIdType *data, vtkIdType len,
| vtkIdType ptOffset=0)
|
| CanConvertTo32BitStorage(...)
| CanConvertTo32BitStorage(self) -> bool
| C++: bool CanConvertTo32BitStorage()
|
| CanConvertTo64BitStorage(...)
| CanConvertTo64BitStorage(self) -> bool
| C++: bool CanConvertTo64BitStorage()
|
| CanConvertToDefaultStorage(...)
| CanConvertToDefaultStorage(self) -> bool
| C++: bool CanConvertToDefaultStorage()
|
| CanConvertToFixedSize32BitStorage(...)
| CanConvertToFixedSize32BitStorage(self) -> bool
| C++: bool CanConvertToFixedSize32BitStorage()
|
| CanConvertToFixedSize64BitStorage(...)
| CanConvertToFixedSize64BitStorage(self) -> bool
| C++: bool CanConvertToFixedSize64BitStorage()
|
| CanConvertToFixedSizeDefaultStorage(...)
| CanConvertToFixedSizeDefaultStorage(self) -> bool
| C++: bool CanConvertToFixedSizeDefaultStorage()
|
| CanConvertToStorageType(...)
| CanConvertToStorageType(self, type:StorageTypes) -> bool
| C++: bool CanConvertToStorageType(StorageTypes type)
|
| ConvertTo32BitStorage(...)
| ConvertTo32BitStorage(self) -> bool
| C++: bool ConvertTo32BitStorage()
|
| ConvertTo64BitStorage(...)
| ConvertTo64BitStorage(self) -> bool
| C++: bool ConvertTo64BitStorage()
|
| ConvertToDefaultStorage(...)
| ConvertToDefaultStorage(self) -> bool
| C++: bool ConvertToDefaultStorage()
|
| ConvertToFixedSize32BitStorage(...)
| ConvertToFixedSize32BitStorage(self) -> bool
| C++: bool ConvertToFixedSize32BitStorage()
|
| ConvertToFixedSize64BitStorage(...)
| ConvertToFixedSize64BitStorage(self) -> bool
| C++: bool ConvertToFixedSize64BitStorage()
|
| ConvertToFixedSizeDefaultStorage(...)
| ConvertToFixedSizeDefaultStorage(self) -> bool
| C++: bool ConvertToFixedSizeDefaultStorage()
|
| ConvertToSmallestStorage(...)
| ConvertToSmallestStorage(self) -> bool
| C++: bool ConvertToSmallestStorage()
|
| ConvertToStorageType(...)
| ConvertToStorageType(self, type:StorageTypes) -> bool
| C++: bool ConvertToStorageType(StorageTypes type)
|
| DeepCopy(...)
| DeepCopy(self, ca:vtkAbstractCellArray) -> None
| C++: void DeepCopy(vtkAbstractCellArray *ca) override;
|
| Perform a deep copy (no reference counting) of the given cell
| array.
|
| EstimateSize(...)
| EstimateSize(self, numCells:int, maxPtsPerCell:int) -> int
| C++: vtkIdType EstimateSize(vtkIdType numCells, int maxPtsPerCell)
|
| Utility routines help manage memory of cell array. EstimateSize()
| returns a value used to initialize and allocate memory for array
| based on number of cells and maximum number of points making up
| cell. If every cell is the same size (in terms of number of
| points), then the memory estimate is guaranteed exact. (If not
| exact, use Squeeze() to reclaim any extra memory.)
|
| ote This method was often misused (e.g. called alone and then
| discarding the result). Use AllocateEstimate directly instead.
|
| ExportLegacyFormat(...)
| ExportLegacyFormat(self, data:vtkIdTypeArray) -> None
| C++: void ExportLegacyFormat(vtkIdTypeArray *data)
|
| Fill data with the old-style vtkCellArray data layout, e.g.
|
| ``` { n0, p0_0, p0_1, ..., p0_n, n1, p1_0, p1_1, ..., p1_n, ... }
| ```
|
| where `n0` is the number of points in cell 0, and `pX_Y` is the
| Y'th point in cell X.
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize()
|
| Return the memory in kibibytes (1024 bytes) consumed by this cell
| array. Used to support streaming and reading/writing data. The
| value returned is guaranteed to be greater than or equal to the
| memory required to actually represent the data represented by
| this object. The information returned is valid only after the
| pipeline has been updated.
|
| GetCell(...)
| GetCell(self, loc:int, npts:int, pts:(int, ...)) -> None
| C++: void GetCell(vtkIdType loc, vtkIdType &npts,
| const vtkIdType *&pts)
| GetCell(self, loc:int, pts:vtkIdList) -> None
| C++: void GetCell(vtkIdType loc, vtkIdList *pts)
|
| Internal method used to retrieve a cell given a legacy offset
| location.
|
| @warning Subsequent calls to this method may invalidate previous
| call
| results.
|
| ote The location-based API is now a super-slow compatibility
| layer. Prefer GetCellAtId.
|
| GetCellAtId(...)
| GetCellAtId(self, cellId:int, cellSize:int, cellPoints:(int, ...),
| ptIds:vtkIdList) -> None
| C++: void GetCellAtId(vtkIdType cellId, vtkIdType &cellSize,
| vtkIdType const *&cellPoints, vtkIdList *ptIds) override;
| GetCellAtId(self, cellId:int, pts:vtkIdList) -> None
| C++: void GetCellAtId(vtkIdType cellId, vtkIdList *pts) override;
| GetCellAtId(self, cellId:int, cellSize:int, cellPoints:[int, ...])
| -> None
| C++: void GetCellAtId(vtkIdType cellId, vtkIdType &cellSize,
| vtkIdType *cellPoints) override;
| GetCellAtId(self, cellId:int, cellSize:int, cellPoints:(int, ...))
| -> None
| C++: void GetCellAtId(vtkIdType cellId, vtkIdType &cellSize,
| vtkIdType const *&cellPoints)
|
| Return the point ids for the cell at cellId.
|
| Subsequent calls to this method may invalidate previous call
| results if the internal storage type is not the same as vtkIdType
| and cannot be shared through the cellPoints pointer. If that
| occurs, the method will use ptIds, which is an object that is
| created by each thread, to guarantee thread safety.
|
| GetCellPointAtId(...)
| GetCellPointAtId(self, cellId:int, cellPointIndex:int) -> int
| C++: vtkIdType GetCellPointAtId(vtkIdType cellId,
| vtkIdType cellPointIndex)
|
| Return the point id at cellPointIndex for the cell at cellId.
|
| GetCellSize(...)
| GetCellSize(self, cellId:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType cellId) override;
|
| Return the size of the cell at cellId.
|
| GetConnectivityAOSArray32(...)
| GetConnectivityAOSArray32(self)
| -> vtkAOSDataArrayTemplate_I12vtkTypeInt32E
| C++: AOSArray32 *GetConnectivityAOSArray32()
|
| GetConnectivityAOSArray64(...)
| GetConnectivityAOSArray64(self)
| -> vtkAOSDataArrayTemplate_I12vtkTypeInt64E
| C++: AOSArray64 *GetConnectivityAOSArray64()
|
| GetConnectivityArray(...)
| GetConnectivityArray(self) -> vtkDataArray
| C++: vtkDataArray *GetConnectivityArray()
|
| GetConnectivityArray32(...)
| GetConnectivityArray32(self) -> vtkTypeInt32Array
| C++: vtkTypeInt32Array *GetConnectivityArray32()
|
| GetConnectivityArray64(...)
| GetConnectivityArray64(self) -> vtkTypeInt64Array
| C++: vtkTypeInt64Array *GetConnectivityArray64()
|
| GetData(...)
| GetData(self) -> vtkIdTypeArray
| C++: vtkIdTypeArray *GetData()
|
| Return the underlying data as a data array.
|
| @warning The returned array is not the actual internal
| representation used
| by vtkCellArray. Modifications to the returned array will not
| change the vtkCellArray's topology.
|
| ote Use ExportLegacyFormat, or
| GetOffsetsArray/GetConnectivityArray instead.
|
| GetDefaultStorageIs64Bit(...)
| GetDefaultStorageIs64Bit() -> bool
| C++: static bool GetDefaultStorageIs64Bit()
|
| GetInsertLocation(...)
| GetInsertLocation(self, npts:int) -> int
| C++: vtkIdType GetInsertLocation(int npts)
|
| Computes the current legacy insertion location within the
| internal array. Used in conjunction with GetCell(int loc,...).
|
| ote The location-based API is now a super-slow compatibility
| layer.
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Returns the size of the largest cell. The size is the number of
| points defining the cell.
|
| GetNextCell(...)
| GetNextCell(self, npts:int, pts:(int, ...)) -> int
| C++: int GetNextCell(vtkIdType &npts, vtkIdType const *&pts)
| GetNextCell(self, pts:vtkIdList) -> int
| C++: int GetNextCell(vtkIdList *pts)
|
| @warning This method is not thread-safe. Consider using the
| NewIterator()
| iterator instead.
|
| GetNextCell() gets the next cell in the list. If end of list is
| encountered, 0 is returned. A value of 1 is returned whenever
| npts and pts have been updated without error.
|
| Do not modify the returned pts pointer, as it may point to shared
| memory.
|
| ote This method is not thread-safe and has tricky syntax to use
| correctly. Prefer the use of vtkCellArrayIterator (see
| NewIterator()).
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| Get the number of cells in the array.
|
| GetNumberOfConnectivityEntries(...)
| GetNumberOfConnectivityEntries(self) -> int
| C++: vtkIdType GetNumberOfConnectivityEntries()
|
| Return the size of the array that would be returned from
| ExportLegacyFormat().
|
| ote Method incompatible with current internal storage.
|
| GetNumberOfConnectivityIds(...)
| GetNumberOfConnectivityIds(self) -> int
| C++: vtkIdType GetNumberOfConnectivityIds() override;
|
| Get the size of the connectivity array that stores the point ids.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfOffsets(...)
| GetNumberOfOffsets(self) -> int
| C++: vtkIdType GetNumberOfOffsets() override;
|
| Get the number of elements in the offsets array. This will be the
| number of cells + 1.
|
| GetOffset(...)
| GetOffset(self, cellId:int) -> int
| C++: vtkIdType GetOffset(vtkIdType cellId) override;
|
| Get the offset (into the connectivity) for a specified cell id.
|
| GetOffsetsAOSArray32(...)
| GetOffsetsAOSArray32(self)
| -> vtkAOSDataArrayTemplate_I12vtkTypeInt32E
| C++: AOSArray32 *GetOffsetsAOSArray32()
|
| GetOffsetsAOSArray64(...)
| GetOffsetsAOSArray64(self)
| -> vtkAOSDataArrayTemplate_I12vtkTypeInt64E
| C++: AOSArray64 *GetOffsetsAOSArray64()
|
| GetOffsetsAffineArray32(...)
| GetOffsetsAffineArray32(self) -> vtkAffineArray_I12vtkTypeInt32E
| C++: AffineArray32 *GetOffsetsAffineArray32()
|
| GetOffsetsAffineArray64(...)
| GetOffsetsAffineArray64(self) -> vtkAffineArray_I12vtkTypeInt64E
| C++: AffineArray64 *GetOffsetsAffineArray64()
|
| GetOffsetsArray(...)
| GetOffsetsArray(self) -> vtkDataArray
| C++: vtkDataArray *GetOffsetsArray()
|
| GetOffsetsArray32(...)
| GetOffsetsArray32(self) -> vtkTypeInt32Array
| C++: vtkTypeInt32Array *GetOffsetsArray32()
|
| GetOffsetsArray64(...)
| GetOffsetsArray64(self) -> vtkTypeInt64Array
| C++: vtkTypeInt64Array *GetOffsetsArray64()
|
| GetSize(...)
| GetSize(self) -> int
| C++: vtkIdType GetSize()
|
| Get the size of the allocated connectivity array.
|
| @warning This returns the allocated capacity of the internal
| arrays as a
| number of elements, NOT the number of elements in use.
|
| ote Method incompatible with current internal storage.
|
| GetStorageType(...)
| GetStorageType(self) -> StorageTypes
| C++: StorageTypes GetStorageType() noexcept;
|
| @return Type of internal storage.
|
| GetTraversalCellId(...)
| GetTraversalCellId(self) -> int
| C++: vtkIdType GetTraversalCellId()
|
| GetTraversalLocation(...)
| GetTraversalLocation(self) -> int
| C++: vtkIdType GetTraversalLocation()
| GetTraversalLocation(self, npts:int) -> int
| C++: vtkIdType GetTraversalLocation(vtkIdType npts)
|
| ImportLegacyFormat(...)
| ImportLegacyFormat(self, data:vtkIdTypeArray) -> None
| C++: void ImportLegacyFormat(vtkIdTypeArray *data)
| ImportLegacyFormat(self, data:(int, ...), len:int) -> None
| C++: void ImportLegacyFormat(const vtkIdType *data, vtkIdType len)
|
| InitTraversal(...)
| InitTraversal(self) -> None
| C++: void InitTraversal()
|
| @warning This method is not thread-safe. Consider using the
| NewIterator()
| iterator instead.
|
| InitTraversal() initializes the traversal of the list of cells.
|
| ote This method is not thread-safe and has tricky syntax to use
| correctly. Prefer the use of vtkCellArrayIterator (see
| NewIterator()).
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Free any memory and reset to an empty state.
|
| InsertCellPoint(...)
| InsertCellPoint(self, id:int) -> None
| C++: void InsertCellPoint(vtkIdType id)
|
| Used in conjunction with InsertNextCell(npts) to add another
| point to the list of cells.
|
| InsertNextCell(...)
| InsertNextCell(self, cell:vtkCell) -> int
| C++: vtkIdType InsertNextCell(vtkCell *cell)
| InsertNextCell(self, npts:int, pts:(int, ...)) -> int
| C++: vtkIdType InsertNextCell(vtkIdType npts,
| const vtkIdType *pts)
| InsertNextCell(self, pts:vtkIdList) -> int
| C++: vtkIdType InsertNextCell(vtkIdList *pts)
| InsertNextCell(self, npts:int) -> int
| C++: vtkIdType InsertNextCell(int npts)
|
| Insert a cell object. Return the cell id of the cell.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsHomogeneous(...)
| IsHomogeneous(self) -> int
| C++: vtkIdType IsHomogeneous() override;
|
| Check if all cells have the same number of vertices.
|
| The return value is coded as:
| * -1 = heterogeneous
| * 0 = Cell array empty
| * n (positive integer) = homogeneous array of cell size n
|
| IsStorage32Bit(...)
| IsStorage32Bit(self) -> bool
| C++: bool IsStorage32Bit()
|
| @return True if the internal storage is using 32 bit arrays.
|
| IsStorage64Bit(...)
| IsStorage64Bit(self) -> bool
| C++: bool IsStorage64Bit()
|
| @return True if the internal storage is using 64 bit arrays.
|
| IsStorageFixedSize(...)
| IsStorageFixedSize(self) -> bool
| C++: bool IsStorageFixedSize()
|
| @return True if the internal storage is using FixedSize arrays.
|
| IsStorageFixedSize32Bit(...)
| IsStorageFixedSize32Bit(self) -> bool
| C++: bool IsStorageFixedSize32Bit()
|
| @return True if the internal storage is using FixedSize 32 bit
| arrays.
|
| IsStorageFixedSize64Bit(...)
| IsStorageFixedSize64Bit(self) -> bool
| C++: bool IsStorageFixedSize64Bit()
|
| @return True if the internal storage is using FixedSize 64 bit
| arrays.
|
| IsStorageGeneric(...)
| IsStorageGeneric(self) -> bool
| C++: bool IsStorageGeneric()
|
| @return True if the internal storage is using vtkDataArray.
|
| IsStorageShareable(...)
| IsStorageShareable(self) -> bool
| C++: bool IsStorageShareable() override;
|
| @return True if the internal storage can be shared as a
| pointer to vtkIdType, i.e., the type and organization of internal
| storage is such that copying of data can be avoided, and instead
| a pointer to vtkIdType can be used.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsValid(...)
| IsValid(self) -> bool
| C++: bool IsValid()
|
| Check that internal storage is consistent and in a valid state.
|
| Specifically, this function returns true if and only if:
| - The offset and connectivity arrays have exactly one component.
| - The offset array has at least one value and starts at 0.
| - The offset array values never decrease.
| - The connectivity array has as many entries as the last value in
| the offset array.
|
| NewInstance(...)
| NewInstance(self) -> vtkCellArray
| C++: vtkCellArray *NewInstance()
|
| NewIterator(...)
| NewIterator(self) -> vtkCellArrayIterator
| C++: vtkCellArrayIterator *NewIterator()
|
| NewIterator returns a new instance of vtkCellArrayIterator that
| is initialized to point at the first cell's data. The caller is
| responsible for Delete()'ing the object.
|
| ReplaceCell(...)
| ReplaceCell(self, loc:int, npts:int, pts:(int, ...)) -> None
| C++: void ReplaceCell(vtkIdType loc, int npts,
| const vtkIdType pts[])
|
| Replace the point ids of the cell at the legacy location with a
| different list of point ids. Calling this method does not mark
| the vtkCellArray as modified. This is the responsibility of the
| caller and may be done after multiple calls to ReplaceCell. This
| call does not support changing the number of points in the cell
| -- the caller must ensure that the target cell has npts points.
|
| ote The location-based API is now a super-slow compatibility
| layer. Prefer ReplaceCellAtId.
|
| ReplaceCellAtId(...)
| ReplaceCellAtId(self, cellId:int, list:vtkIdList) -> None
| C++: void ReplaceCellAtId(vtkIdType cellId, vtkIdList *list)
| ReplaceCellAtId(self, cellId:int, cellSize:int, cellPoints:(int,
| ...)) -> None
| C++: void ReplaceCellAtId(vtkIdType cellId, vtkIdType cellSize,
| const vtkIdType *cellPoints)
|
| ReplaceCellPointAtId(...)
| ReplaceCellPointAtId(self, cellId:int, cellPointIndex:int,
| newPointId:int) -> None
| C++: void ReplaceCellPointAtId(vtkIdType cellId,
| vtkIdType cellPointIndex, vtkIdType newPointId)
|
| Replaces the pointId at cellPointIndex of a cell with newPointId.
|
| @warning This can ONLY replace the cell if the size does not
| change.
| Attempting to change cell size through this method will have
| undefined results.
|
| Reset(...)
| Reset(self) -> None
| C++: void Reset()
|
| Reuse list. Reset to initial state without freeing memory.
|
| ResizeExact(...)
| ResizeExact(self, numCells:int, connectivitySize:int) -> bool
| C++: bool ResizeExact(vtkIdType numCells,
| vtkIdType connectivitySize)
|
| ResizeExact() resizes the internal structures to hold numCells
| total cell offsets and connectivitySize total pointIds. Old data
| is preserved, and newly-available memory is not initialized.
|
| @warning For advanced use only. You probably want an Allocate
| method.
|
| @return True if allocation succeeds.
|
| ReverseCell(...)
| ReverseCell(self, loc:int) -> None
| C++: void ReverseCell(vtkIdType loc)
|
| Special method inverts ordering of cell at the specified legacy
| location. Must be called carefully or the cell topology may be
| corrupted.
|
| ote The location-based API is now a super-slow compatibility
| layer. Prefer ReverseCellAtId;
|
| ReverseCellAtId(...)
| ReverseCellAtId(self, cellId:int) -> None
| C++: void ReverseCellAtId(vtkIdType cellId)
|
| Reverses the order of the point ids for the specified cell.
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkCellArray
| C++: static vtkCellArray *SafeDownCast(vtkObjectBase *o)
|
| SetCells(...)
| SetCells(self, ncells:int, cells:vtkIdTypeArray) -> None
| C++: void SetCells(vtkIdType ncells, vtkIdTypeArray *cells)
|
| Define multiple cells by providing a connectivity list. The list
| is in the form (npts,p0,p1,...p(npts-1), repeated for each cell).
| Be careful using this method because it discards the old cells,
| and anything referring these cells becomes invalid (for example,
| if BuildCells() has been called see vtkPolyData). The traversal
| location is reset to the beginning of the list; the insertion
| location is set to the end of the list.
|
| @warning The vtkCellArray will not hold a reference to `cells`.
| This
| function merely calls ImportLegacyFormat.
|
| ote Use ImportLegacyFormat or SetData instead.
|
| SetData(...)
| SetData(self, __a:vtkAOSDataArrayTemplate_I12vtkTypeInt32E,
| connectivity:vtkAOSDataArrayTemplate_I12vtkTypeInt32E) -> None
| C++: void SetData(AOSArray32 *, AOSArray32 *connectivity)
| SetData(self, __a:vtkAOSDataArrayTemplate_I12vtkTypeInt64E,
| connectivity:vtkAOSDataArrayTemplate_I12vtkTypeInt64E) -> None
| C++: void SetData(AOSArray64 *, AOSArray64 *connectivity)
| SetData(self, __a:vtkAffineArray_I12vtkTypeInt32E,
| connectivity:vtkAOSDataArrayTemplate_I12vtkTypeInt32E) -> None
| C++: void SetData(AffineArray32 *, AOSArray32 *connectivity)
| SetData(self, __a:vtkAffineArray_I12vtkTypeInt64E,
| connectivity:vtkAOSDataArrayTemplate_I12vtkTypeInt64E) -> None
| C++: void SetData(AffineArray64 *, AOSArray64 *connectivity)
| SetData(self, offsets:vtkDataArray, connectivity:vtkDataArray)
| -> bool
| C++: bool SetData(vtkDataArray *offsets,
| vtkDataArray *connectivity)
| SetData(self, cellSize:int, connectivity:vtkDataArray) -> bool
| C++: bool SetData(vtkIdType cellSize, vtkDataArray *connectivity)
|
| Set the internal data arrays to the supplied offsets and
| connectivity arrays.
|
| For connectivity use vtkCellArray::AOSArray32, or
| vtkCellArray::AOSArray64, which are part of
| vtkArrayDispatch::ConnectivityArrays.
|
| For offsets use vtkCellArray::AOSArray32,
| vtkCellArray::AOSArray64, vtkCellArray::AffineArray32 or
| vtkCellArray::AffineArray64, which are part of
| vtkArrayDispatch::OffsetsArrays.
|
| If the arrays are nullptr, or they don't have 1 component, an
| error is logged.
|
| SetDefaultStorageIs64Bit(...)
| SetDefaultStorageIs64Bit(val:bool) -> None
| C++: static void SetDefaultStorageIs64Bit(bool val)
|
| SetNumberOfCells(...)
| SetNumberOfCells(self, __a:int) -> None
| C++: virtual void SetNumberOfCells(vtkIdType)
|
| Set the number of cells in the array. DO NOT do any kind of
| allocation, advanced use only.
|
| ote This call has no effect.
|
| SetOffset(...)
| SetOffset(self, cellId:int, offset:int) -> None
| C++: void SetOffset(vtkIdType cellId, vtkIdType offset)
|
| Set the offset (into the connectivity) for a specified cell id.
|
| SetTraversalCellId(...)
| SetTraversalCellId(self, cellId:int) -> None
| C++: void SetTraversalCellId(vtkIdType cellId)
|
| SetTraversalLocation(...)
| SetTraversalLocation(self, loc:int) -> None
| C++: void SetTraversalLocation(vtkIdType loc)
|
| ShallowCopy(...)
| ShallowCopy(self, ca:vtkAbstractCellArray) -> None
| C++: void ShallowCopy(vtkAbstractCellArray *ca) override;
|
| Shallow copy ca into this cell array.
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: void Squeeze()
|
| Reclaim any extra memory while preserving data.
|
| @sa ConvertToSmallestStorage
|
| UpdateCellCount(...)
| UpdateCellCount(self, npts:int) -> None
| C++: void UpdateCellCount(int npts)
|
| Used in conjunction with InsertNextCell(int npts) and
| InsertCellPoint() to update the number of points defining the
| cell.
|
| Use32BitStorage(...)
| Use32BitStorage(self) -> None
| C++: void Use32BitStorage()
|
| Use64BitStorage(...)
| Use64BitStorage(self) -> None
| C++: void Use64BitStorage()
|
| UseDefaultStorage(...)
| UseDefaultStorage(self) -> None
| C++: void UseDefaultStorage()
|
| UseFixedSize32BitStorage(...)
| UseFixedSize32BitStorage(self, cellSize:int) -> None
| C++: void UseFixedSize32BitStorage(vtkIdType cellSize)
|
| UseFixedSize64BitStorage(...)
| UseFixedSize64BitStorage(self, cellSize:int) -> None
| C++: void UseFixedSize64BitStorage(vtkIdType cellSize)
|
| UseFixedSizeDefaultStorage(...)
| UseFixedSizeDefaultStorage(self, cellSize:int) -> None
| C++: void UseFixedSizeDefaultStorage(vtkIdType cellSize)
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkCommonDataModel.vtkCellArray:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkCommonDataModel.vtkCellArray
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkCellArray:
|
| __this__
| Pointer to the C++ object.
|
| actual_memory_size
| read-only, calls GetActualMemorySize
|
| connectivity_aos_array32
| read-only, calls GetConnectivityAOSArray32
|
| connectivity_aos_array64
| read-only, calls GetConnectivityAOSArray64
|
| connectivity_array32
| read-only, calls GetConnectivityArray32
|
| connectivity_array64
| read-only, calls GetConnectivityArray64
|
| data
| read-only, calls GetData
|
| default_storage_is64_bit
| read-write, calls GetDefaultStorageIs64Bit/SetDefaultStorageIs64Bit
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| number_of_cells
| read-write, calls GetNumberOfCells/SetNumberOfCells
|
| number_of_connectivity_entries
| read-only, calls GetNumberOfConnectivityEntries
|
| number_of_connectivity_ids
| read-only, calls GetNumberOfConnectivityIds
|
| number_of_offsets
| read-only, calls GetNumberOfOffsets
|
| offsets_affine_array32
| read-only, calls GetOffsetsAffineArray32
|
| offsets_affine_array64
| read-only, calls GetOffsetsAffineArray64
|
| offsets_aos_array32
| read-only, calls GetOffsetsAOSArray32
|
| offsets_aos_array64
| read-only, calls GetOffsetsAOSArray64
|
| offsets_array
| read-only, calls GetOffsetsArray
|
| offsets_array32
| read-only, calls GetOffsetsArray32
|
| offsets_array64
| read-only, calls GetOffsetsArray64
|
| size
| read-only, calls GetSize
|
| storage_type
| read-only, calls GetStorageType
|
| traversal_cell_id
| read-write, calls GetTraversalCellId/SetTraversalCellId
|
| traversal_location
| read-write, calls GetTraversalLocation/SetTraversalLocation
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkCellArray:
|
| FixedSizeInt32 = 3
|
| FixedSizeInt64 = 2
|
| Generic = 4
|
| Int32 = 1
|
| Int64 = 0
|
| StorageTypes = <class 'vtkmodules.vtkCommonDataModel.vtkCellArray.Stor...
|
| __vtkname__ = 'vtkCellArray'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.CellArrayLike
Python Library Documentation: _UnionGenericAlias in module typing
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
pyvista.CellStatus
Python Library Documentation: class CellStatus in module pyvista.core.filters.data_object class CellStatus(enum.IntEnum) | CellStatus(*values) | | Cell status bits used by :meth:`~pyvista.DataObjectFilters.cell_validator`. | | Most cell status values are used by :vtk:`vtkCellValidator` directly. Additional | PyVista-exclusive values are also included. | | Method resolution order: | CellStatus | enum.IntEnum | builtins.int | enum.ReprEnum | enum.Enum | builtins.object | | Methods defined here: | | __format__(self, format_spec, /) from builtins.int | Convert to a string according to format_spec. | | __new__(cls, value) from enum.Enum | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | COINCIDENT_POINTS = <CellStatus.COINCIDENT_POINTS: 256> | Cell has duplicate coordinates or repeated use of the same connectivity entry. | | | DEGENERATE_FACES = <CellStatus.DEGENERATE_FACES: 128> | Face(s) collapse to a line or a point through repeated collocated vertices. | | | INTERSECTING_EDGES = <CellStatus.INTERSECTING_EDGES: 2> | 2D cell has two edges that intersect. | | | INTERSECTING_FACES = <CellStatus.INTERSECTING_FACES: 4> | 3D cell has two faces that intersect. | | | INVALID_POINT_REFERENCES = <CellStatus.INVALID_POINT_REFERENCES: 65536... | Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array. | | | INVERTED_FACES = <CellStatus.INVERTED_FACES: 32> | Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`. | | | NEGATIVE_SIZE = <CellStatus.NEGATIVE_SIZE: 1048576> | 1D, 2D, or 3D cell has negative length, area, or volume, respectively. | | | NON_CONTIGUOUS_EDGES = <CellStatus.NON_CONTIGUOUS_EDGES: 8> | 2D cell's perimeter edges are not contiguous. | | | NON_CONVEX = <CellStatus.NON_CONVEX: 16> | 2D or 3D cell is not convex. | | | NON_PLANAR_FACES = <CellStatus.NON_PLANAR_FACES: 64> | Vertices for a face do not all lie in the same plane. | | | VALID = <CellStatus.VALID: 0> | Cell is valid and has no issues. | | | WRONG_NUMBER_OF_POINTS = <CellStatus.WRONG_NUMBER_OF_POINTS: 1> | Cell does not have the minimum number of points needed to describe it. | | | ZERO_SIZE = <CellStatus.ZERO_SIZE: 131072> | 1D, 2D, or 3D cell has zero length, area, or volume, respectively. | | | ---------------------------------------------------------------------- | Methods inherited from enum.IntEnum: | | __repr__(self) from enum.Enum | Return repr(self). | | __str__ = __repr__(self, /) from builtins.int | Return repr(self). | | ---------------------------------------------------------------------- | Methods inherited from builtins.int: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | True if self else False | | __ceil__(...) | Ceiling of an Integral returns itself. | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floor__(...) | Flooring an Integral returns itself. | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(self, /) | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __round__(...) | Rounding an Integral returns itself. | | Rounding with an ndigits argument also returns an integer. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __sizeof__(self, /) | Returns size in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __trunc__(...) | Truncating an Integral returns itself. | | __xor__(self, value, /) | Return self^value. | | as_integer_ratio(self, /) | Return a pair of integers, whose ratio is equal to the original int. | | The ratio is in lowest terms and has a positive denominator. | | >>> (10).as_integer_ratio() | (10, 1) | >>> (-10).as_integer_ratio() | (-10, 1) | >>> (0).as_integer_ratio() | (0, 1) | | bit_count(self, /) | Number of ones in the binary representation of the absolute value of self. | | Also known as the population count. | | >>> bin(13) | '0b1101' | >>> (13).bit_count() | 3 | | bit_length(self, /) | Number of bits necessary to represent self in binary. | | >>> bin(37) | '0b100101' | >>> (37).bit_length() | 6 | | conjugate(...) | Returns self, the complex conjugate of any int. | | is_integer(self, /) | Returns True. Exists for duck type compatibility with float.is_integer. | | to_bytes(self, /, length=1, byteorder='big', *, signed=False) | Return an array of bytes representing an integer. | | length | Length of bytes object to use. An OverflowError is raised if the | integer is not representable with the given number of bytes. Default | is length 1. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Determines whether two's complement is used to represent the integer. | If signed is False and a negative integer is given, an OverflowError | is raised. | | ---------------------------------------------------------------------- | Class methods inherited from builtins.int: | | from_bytes(bytes, byteorder='big', *, signed=False) | Return the integer represented by the given array of bytes. | | bytes | Holds the array of bytes to convert. The argument must either | support the buffer protocol or be an iterable object producing bytes. | Bytes and bytearray are examples of built-in objects that support the | buffer protocol. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Indicates whether two's complement is used to represent the integer. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.int: | | denominator | the denominator of a rational number in lowest terms | | imag | the imaginary part of a complex number | | numerator | the numerator of a rational number in lowest terms | | real | the real part of a complex number | | ---------------------------------------------------------------------- | Methods inherited from enum.Enum: | | __dir__(self) | Returns public methods and other interesting attributes. | | __init__(self, *args, **kwds) | Initialize self. See help(type(self)) for accurate signature. | | __reduce_ex__(self, proto) | Helper for pickle. | | ---------------------------------------------------------------------- | Data descriptors inherited from enum.Enum: | | name | The name of the Enum member. | | value | The value of the Enum member. | | ---------------------------------------------------------------------- | Static methods inherited from enum.EnumType: | | __contains__(value) | Return True if `value` is in `cls`. | | `value` is in `cls` if: | 1) `value` is a member of `cls`, or | 2) `value` is the value of one of the `cls`'s members. | | __getitem__(name) | Return the member matching `name`. | | __iter__() | Return members in definition order. | | __len__() | Return the number of members (no aliases) | | ---------------------------------------------------------------------- | Readonly properties inherited from enum.EnumType: | | __members__ | Returns a mapping of member name->value. | | This mapping lists all enum members, including aliases. Note that this | is a read-only view of the internal mapping.
pyvista.CellType
Python Library Documentation: class CellType in module pyvista.core.celltype class CellType(enum.IntEnum) | CellType(*values) | | Define types of cells. | | Cells are defined by specifying a type in combination with an ordered list of points. | The ordered list, often referred to as the connectivity list, combined with the | type specification, implicitly defines the topology of the cell. The x-y-z point | coordinates define the cell geometry. | | Although point coordinates are defined in three dimensions, the cell topology can | be 0, 1, 2, or 3-dimensional. Use :attr:`dimension` to check the topological dimension. | | Cells can be primary (e.g. triangle) or composite (e.g. triangle strip). Composite | cells consist of one or more primary cells, while primary cells cannot be | decomposed. Use :attr:`is_composite` to check if a cell type is primary or composite. | | Cells can also be characterized as linear or non-linear. Linear cells use | linear or constant interpolation, while non-linear cells may use quadratic, | cubic, or some other interpolation. Use :attr:`is_linear` to check if a cell type is linear. | | Higher order interpolation is possible using Lagrange or Bézier cells. For Lagrange cells, | all the points lie on the interpolation curve, whereas for the Bézier cells, only the points at | the extremities are interpolatory. | | This enumeration defines all cell types used in VTK and supported by PyVista. The | type(s) of cell(s) to use is typically chosen based on application need, such as | graphics rendering or numerical simulation. | | .. seealso:: | | :class:`pyvista.Cell` | Wrapper for instances of :vtk:`vtkCell`. | | :mod:`pyvista.examples.cells` | Examples creating a mesh comprising a single cell. | | :ref:`linear_cells_example` | Detailed example using linear cells. | | :ref:`create_polyhedron_example` | Example creating a mesh with :attr:`~pyvista.CellType.POLYHEDRON` cells. | | :ref:`create_polydata_strips_example` | Example creating a mesh with :attr:`~pyvista.CellType.TRIANGLE_STRIP` cells. | | References | ---------- | `VTK Book: Cell Types <https://book.vtk.org/en/latest/VTKBook/05Chapter5.html#cell-types>`_ | VTK reference about cell types. | | `Modeling Lagrange Finite Elements in VTK <https://www.kitware.com//modeling-arbitrary-order-lagrange-finite-elements-in-the-visualization-toolkit/>`_ | VTK blog post about Lagrange cells. | | `Implementation of rational Bézier cells into VTK <https://www.kitware.com/implementation-of-rational-bezier-cells-into-vtk/>`_ | VTK blog post about Bezier cells. | | `vtkCellType.h <https://vtk.org/doc/nightly/html/vtkCellType_8h_source.html>`_ | List of all cell types defined in VTK. | | Examples | -------- | Create a single cube. Notice how the cell type is defined using the | ``CellType``. | | >>> import numpy as np | >>> from pyvista import CellType | >>> import pyvista as pv | >>> cells = np.array([8, 0, 1, 2, 3, 4, 5, 6, 7]) | >>> cell_type = np.array([CellType.HEXAHEDRON], np.int8) | >>> points = np.array( | ... [ | ... [0, 0, 0], | ... [1, 0, 0], | ... [1, 1, 0], | ... [0, 1, 0], | ... [0, 0, 1], | ... [1, 0, 1], | ... [1, 1, 1], | ... [0, 1, 1], | ... ], | ... dtype=np.float32, | ... ) | >>> grid = pv.UnstructuredGrid(cells, cell_type, points) | >>> grid | UnstructuredGrid (...) | N Cells: 1 | N Points: 8 | X Bounds: 0.000e+00, 1.000e+00 | Y Bounds: 0.000e+00, 1.000e+00 | Z Bounds: 0.000e+00, 1.000e+00 | N Arrays: 0 | | Method resolution order: | CellType | enum.IntEnum | builtins.int | enum.ReprEnum | enum.Enum | builtins.object | | Methods defined here: | | __format__(self, format_spec, /) from builtins.int | Convert to a string according to format_spec. | | __new__(cls, value) from enum.Enum | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | BEZIER_CURVE = <CellType.BEZIER_CURVE: 75> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.BezierCurve | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BezierCurve-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`1D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Bezier representation of a curve with arbitrary order. | | See also :vtk:`vtkBezierCurve`. | | | BEZIER_HEXAHEDRON = <CellType.BEZIER_HEXAHEDRON: 79> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.BezierHexahedron | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BezierHexahedron-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 12 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 6 <pyvista.CellType.n_faces>` | | Bezier representation of a hexahedron with arbitrary order. | | See also :vtk:`vtkBezierHexahedron`. | | | BEZIER_PYRAMID = <CellType.BEZIER_PYRAMID: 81> | .. grid:: 1 | :margin: 1 | | .. grid-item:: | | | | Bezier representation of a pyramid with arbitrary order. | | | BEZIER_QUADRILATERAL = <CellType.BEZIER_QUADRILATERAL: 77> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.BezierQuadrilateral | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BezierQuadrilateral-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 4 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Bezier representation of a quadrilateral with arbitrary order. | | See also :vtk:`vtkBezierQuadrilateral`. | | | BEZIER_TETRAHEDRON = <CellType.BEZIER_TETRAHEDRON: 78> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.BezierTetrahedron | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BezierTetrahedron-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 6 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 4 <pyvista.CellType.n_faces>` | | Bezier representation of a tetrahedron with arbitrary order. | | See also :vtk:`vtkBezierTetra`. | | | BEZIER_TRIANGLE = <CellType.BEZIER_TRIANGLE: 76> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.BezierTriangle | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BezierTriangle-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 3 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Bezier representation of a triangle with arbitrary order. | | See also :vtk:`vtkBezierTriangle`. | | | BEZIER_WEDGE = <CellType.BEZIER_WEDGE: 80> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.BezierWedge | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BezierWedge-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 9 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>` | | Bezier representation of a wedge with arbitrary order. | | See also :vtk:`vtkBezierWedge`. | | | BIQUADRATIC_QUAD = <CellType.BIQUADRATIC_QUAD: 28> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.BiQuadraticQuadrilateral | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BiQuadraticQuadrilateral-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 9 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 4 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a 2D, 9-node iso-parametric parabolic quadrilateral element with a center-point. | | The cell includes a mid-edge node for each of the four edges of the cell and | a center node at the surface. | | See also :vtk:`vtkBiQuadraticQuad`. | | | BIQUADRATIC_QUADRATIC_HEXAHEDRON = <CellType.BIQUADRATIC_QUADRATIC_HEX... | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.BiQuadraticQuadraticHexahedron | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BiQuadraticQuadraticHexahedron-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 24 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 12 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 6 <pyvista.CellType.n_faces>` | | Represents a 3D, 24-node iso-parametric biquadratic hexahedron. | | The cell includes mid-edge and center-face nodes. | | See also :vtk:`vtkBiQuadraticQuadraticHexahedron`. | | | BIQUADRATIC_QUADRATIC_WEDGE = <CellType.BIQUADRATIC_QUADRATIC_WEDGE: 3... | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.BiQuadraticQuadraticWedge | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BiQuadraticQuadraticWedge-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 18 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 9 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>` | | Represents a 3D, 18-node iso-parametric bi-quadratic wedge. | | The cell includes a mid-edge node. | | See also :vtk:`vtkBiQuadraticQuadraticWedge`. | | | BIQUADRATIC_TRIANGLE = <CellType.BIQUADRATIC_TRIANGLE: 34> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.BiQuadraticTriangle | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BiQuadraticTriangle-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 7 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 3 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a 2D, 7-node, iso-parametric parabolic triangle. | | The cell includes three mid-edge nodes besides the three triangle vertices | and a center node. | | See also :vtk:`vtkBiQuadraticTriangle`. | | | CONVEX_POINT_SET = <CellType.CONVEX_POINT_SET: 41> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.ConvexPointSet | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-ConvexPointSet-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Composite <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: variable <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: variable <pyvista.CellType.n_faces>` | | Represents a 3D cell defined by a convex set of points. | | See also :vtk:`vtkConvexPointSet`. | | | CUBIC_LINE = <CellType.CUBIC_LINE: 35> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.CubicLine | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-CubicLine-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`1D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 4 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a 1D iso-parametric cubic line. | | The cell includes two mid-edge nodes. | | See also :vtk:`vtkCubicLine`. | | | EMPTY_CELL = <CellType.EMPTY_CELL: 0> | .. grid:: 1 | :margin: 1 | | .. grid-item:: | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`0D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 0 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Used as a place-holder during processing. | | See also :vtk:`vtkEmptyCell`. | | | HEXAGONAL_PRISM = <CellType.HEXAGONAL_PRISM: 16> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.HexagonalPrism | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-HexagonalPrism-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 12 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 18 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 8 <pyvista.CellType.n_faces>` | | Represents a 3D prism with hexagonal base and six quadrilateral faces. | | The hexagonal prism is a primary three-dimensional cell defined by an ordered | list of twelve points. | | See also :vtk:`vtkHexagonalPrism`. | | | HEXAHEDRON = <CellType.HEXAHEDRON: 12> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.Hexahedron | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Hexahedron-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 8 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 12 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 6 <pyvista.CellType.n_faces>` | | Represents a 3D rectangular hexahedron. | | The hexahedron is a primary three-dimensional cell consisting of six | quadrilateral faces, twelve edges, and eight vertices. | | See also :vtk:`vtkHexahedron`. | | | HIGHER_ORDER_EDGE = <CellType.HIGHER_ORDER_EDGE: 60> | | HIGHER_ORDER_HEXAHEDRON = <CellType.HIGHER_ORDER_HEXAHEDRON: 67> | | HIGHER_ORDER_POLYGON = <CellType.HIGHER_ORDER_POLYGON: 63> | | HIGHER_ORDER_PYRAMID = <CellType.HIGHER_ORDER_PYRAMID: 66> | | HIGHER_ORDER_QUAD = <CellType.HIGHER_ORDER_QUAD: 62> | | HIGHER_ORDER_TETRAHEDRON = <CellType.HIGHER_ORDER_TETRAHEDRON: 64> | | HIGHER_ORDER_TRIANGLE = <CellType.HIGHER_ORDER_TRIANGLE: 61> | | HIGHER_ORDER_WEDGE = <CellType.HIGHER_ORDER_WEDGE: 65> | | LAGRANGE_CURVE = <CellType.LAGRANGE_CURVE: 68> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.LagrangeCurve | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-LagrangeCurve-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`1D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Lagrange representation of a curve with arbitrary order. | | See also :vtk:`vtkLagrangeCurve`. | | | LAGRANGE_HEXAHEDRON = <CellType.LAGRANGE_HEXAHEDRON: 72> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.LagrangeHexahedron | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-LagrangeHexahedron-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 12 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 6 <pyvista.CellType.n_faces>` | | Lagrange representation of a hexahedron with arbitrary order. | | See also :vtk:`vtkLagrangeHexahedron`. | | | LAGRANGE_PYRAMID = <CellType.LAGRANGE_PYRAMID: 74> | .. grid:: 1 | :margin: 1 | | .. grid-item:: | | | | Lagrange representation of a pyramid with arbitrary order. | | | LAGRANGE_QUADRILATERAL = <CellType.LAGRANGE_QUADRILATERAL: 70> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.LagrangeQuadrilateral | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-LagrangeQuadrilateral-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 4 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Lagrange representation of a quadrilateral with arbitrary order. | | See also :vtk:`vtkLagrangeQuadrilateral`. | | | LAGRANGE_TETRAHEDRON = <CellType.LAGRANGE_TETRAHEDRON: 71> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.LagrangeTetrahedron | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-LagrangeTetrahedron-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 6 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 4 <pyvista.CellType.n_faces>` | | Lagrange representation of a tetrahedron with arbitrary order. | | See also :vtk:`vtkLagrangeTetra`. | | | LAGRANGE_TRIANGLE = <CellType.LAGRANGE_TRIANGLE: 69> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.LagrangeTriangle | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-LagrangeTriangle-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 3 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Lagrange representation of a triangle with arbitrary order. | | See also :vtk:`vtkLagrangeTriangle`. | | | LAGRANGE_WEDGE = <CellType.LAGRANGE_WEDGE: 73> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.LagrangeWedge | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-LagrangeWedge-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 9 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>` | | Lagrange representation of a wedge with arbitrary order. | | See also :vtk:`vtkLagrangeWedge`. | | | LINE = <CellType.LINE: 3> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.Line | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Line-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`1D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 2 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a 1D line. | | The line is a primary one-dimensional cell. It is defined by two points. | The direction along the line is from the first point to the second point. | | See also :vtk:`vtkLine`. | | | PARAMETRIC_CURVE = <CellType.PARAMETRIC_CURVE: 51> | | PARAMETRIC_HEX_REGION = <CellType.PARAMETRIC_HEX_REGION: 56> | | PARAMETRIC_QUAD_SURFACE = <CellType.PARAMETRIC_QUAD_SURFACE: 54> | | PARAMETRIC_SURFACE = <CellType.PARAMETRIC_SURFACE: 52> | | PARAMETRIC_TETRA_REGION = <CellType.PARAMETRIC_TETRA_REGION: 55> | | PARAMETRIC_TRI_SURFACE = <CellType.PARAMETRIC_TRI_SURFACE: 53> | | PENTAGONAL_PRISM = <CellType.PENTAGONAL_PRISM: 15> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.PentagonalPrism | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-PentagonalPrism-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 10 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 15 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 7 <pyvista.CellType.n_faces>` | | Represents a convex 3D prism with a pentagonal base and five quadrilateral faces. | | The pentagonal prism is a primary three-dimensional cell defined by an ordered | list of ten points. | | See also :vtk:`vtkPentagonalPrism`. | | | PIXEL = <CellType.PIXEL: 8> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.Pixel | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Pixel-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 4 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 4 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a 2D orthogonal quadrilateral. | | The pixel is a primary two-dimensional cell defined by an ordered list of four | points. | | .. warning:: | This definition of a pixel differs from the conventional definition which | describes a single constant-valued element in an image. The meaning of this | term can vary depending on context. See :ref:`image_representations_example` | for examples. | | See also :vtk:`vtkPixel`. | | | POLYGON = <CellType.POLYGON: 7> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.Polygon | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Polygon-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Composite <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: variable <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a 2D n-sided polygon. | | The polygon is a primary two-dimensional cell. It is defined by an ordered list | of three or more points lying in a plane. | | See also :vtk:`vtkPolygon`. | | | POLYHEDRON = <CellType.POLYHEDRON: 42> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.Polyhedron | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Polyhedron-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: variable <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: variable <pyvista.CellType.n_faces>` | | Represents a 3D cell defined by a set of polygonal faces. | | See also :vtk:`vtkPolyhedron`. | | | POLY_LINE = <CellType.POLY_LINE: 4> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.PolyLine | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-PolyLine-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Composite <pyvista.CellType.is_composite>` :bdg-link-secondary:`1D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a set of 1D lines. | | The polyline is a composite one-dimensional cell consisting of one or more | connected lines. | | See also :vtk:`vtkPolyLine`. | | | POLY_VERTEX = <CellType.POLY_VERTEX: 2> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.PolyVertex | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-PolyVertex-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Composite <pyvista.CellType.is_composite>` :bdg-link-secondary:`0D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a set of points in 3D space. | | The polyvertex is a composite zero-dimensional cell. It is defined by an | arbitrarily ordered list of points. | | See also :vtk:`vtkPolyVertex`. | | | PYRAMID = <CellType.PYRAMID: 14> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.Pyramid | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Pyramid-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 5 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 8 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>` | | Represents a 3D pyramid. | | The pyramid is a primary three-dimensional cell consisting of a rectangular base | with four triangular faces. It is defined by an ordered list of five points. | | See also :vtk:`vtkPyramid`. | | | QUAD = <CellType.QUAD: 9> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.Quadrilateral | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Quadrilateral-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 4 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 4 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a 2D quadrilateral. | | The quadrilateral is a primary two-dimensional cell. It is defined by an ordered | list of four points lying in a plane. | | See also :vtk:`vtkQuad`. | | | QUADRATIC_EDGE = <CellType.QUADRATIC_EDGE: 21> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.QuadraticEdge | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticEdge-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`1D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 3 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a 1D, 3-node, iso-parametric parabolic line. | | The cell includes a mid-edge node. | | See also :vtk:`vtkQuadraticEdge`. | | | QUADRATIC_HEXAHEDRON = <CellType.QUADRATIC_HEXAHEDRON: 25> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.QuadraticHexahedron | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticHexahedron-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 20 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 12 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 6 <pyvista.CellType.n_faces>` | | Represents a 3D, 20-node iso-parametric parabolic hexahedron. | | The cell includes a mid-edge node. | | See also :vtk:`vtkQuadraticHexahedron`. | | | QUADRATIC_LINEAR_QUAD = <CellType.QUADRATIC_LINEAR_QUAD: 30> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.QuadraticLinearQuadrilateral | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticLinearQuadrilateral-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 6 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 4 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a 2D, 6-node iso-parametric quadratic-linear quadrilateral element. | | The cell includes a mid-edge node for two of the four edges. | | See also :vtk:`vtkQuadraticLinearQuad`. | | | QUADRATIC_LINEAR_WEDGE = <CellType.QUADRATIC_LINEAR_WEDGE: 31> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.QuadraticLinearWedge | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticLinearWedge-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 12 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 9 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>` | | Represents a 3D, 12-node iso-parametric linear quadratic wedge. | | The cell includes mid-edge node in the triangle edges. | | See also :vtk:`vtkQuadraticLinearWedge`. | | | QUADRATIC_POLYGON = <CellType.QUADRATIC_POLYGON: 36> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.QuadraticPolygon | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticPolygon-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Composite <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: variable <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a 2D n-sided (2*n nodes) parabolic polygon. | | The polygon cannot have any internal holes, and cannot self-intersect. | The cell includes a mid-edge node for each of the n edges of the cell. | | See also :vtk:`vtkQuadraticPolygon`. | | | QUADRATIC_PYRAMID = <CellType.QUADRATIC_PYRAMID: 27> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.QuadraticPyramid | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticPyramid-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 13 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 8 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>` | | Represents a 3D, 13-node iso-parametric parabolic pyramid. | | The cell includes a mid-edge node. | | See also :vtk:`vtkQuadraticPyramid`. | | | QUADRATIC_QUAD = <CellType.QUADRATIC_QUAD: 23> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.QuadraticQuadrilateral | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticQuadrilateral-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 8 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 4 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a 2D, 8-node iso-parametric parabolic quadrilateral element. | | The cell includes a mid-edge node for each of the four edges of the cell. | | See also :vtk:`vtkQuadraticQuad`. | | | QUADRATIC_TETRA = <CellType.QUADRATIC_TETRA: 24> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.QuadraticTetrahedron | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticTetrahedron-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 10 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 6 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 4 <pyvista.CellType.n_faces>` | | Represents a 3D, 10-node, iso-parametric parabolic tetrahedron. | | The cell includes a mid-edge node on each of the side edges of the tetrahedron. | | See also :vtk:`vtkQuadraticTetra`. | | | QUADRATIC_TRIANGLE = <CellType.QUADRATIC_TRIANGLE: 22> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.QuadraticTriangle | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticTriangle-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 6 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 3 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a 2D, 6-node, iso-parametric parabolic triangle. | | The cell includes a mid-edge node for each of the three edges of the cell. | | See also :vtk:`vtkQuadraticTriangle`. | | | QUADRATIC_WEDGE = <CellType.QUADRATIC_WEDGE: 26> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.QuadraticWedge | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticWedge-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 15 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 9 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>` | | Represents a 3D, 15-node iso-parametric parabolic wedge. | | The cell includes a mid-edge node. | | See also :vtk:`vtkQuadraticWedge`. | | | TETRA = <CellType.TETRA: 10> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.Tetrahedron | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Tetrahedron-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 4 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 6 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 4 <pyvista.CellType.n_faces>` | | Represents a 3D tetrahedron. | | The tetrahedron is a primary three-dimensional cell. The tetrahedron is defined | by a list of four non-planar points. It has six edges and four triangular faces. | | See also :vtk:`vtkTetra`. | | | TRIANGLE = <CellType.TRIANGLE: 5> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.Triangle | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Triangle-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 3 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 3 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a 2D triangle. | | The triangle is a primary two-dimensional cell. The triangle is defined by a | counter-clockwise ordered list of three points. | | See also :vtk:`vtkTriangle`. | | | TRIANGLE_STRIP = <CellType.TRIANGLE_STRIP: 6> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.TriangleStrip | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-TriangleStrip-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Composite <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: variable <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a 2D triangle strip. | | The triangle strip is a composite two-dimensional cell consisting of one or more | triangles. It is a compact representation of triangles connected edge-to-edge. | | See also :vtk:`vtkTriangleStrip`. | | | TRIQUADRATIC_HEXAHEDRON = <CellType.TRIQUADRATIC_HEXAHEDRON: 29> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.TriQuadraticHexahedron | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-TriQuadraticHexahedron-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 27 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 12 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 6 <pyvista.CellType.n_faces>` | | Represents a 3D, 27-node iso-parametric triquadratic hexahedron. | | The cell includes 8 edge nodes, 12 mid-edge nodes, 6 mid-face nodes and one | mid-volume node. | | See also :vtk:`vtkTriQuadraticHexahedron`. | | | TRIQUADRATIC_PYRAMID = <CellType.TRIQUADRATIC_PYRAMID: 37> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.TriQuadraticPyramid | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-TriQuadraticPyramid-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 19 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 8 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>` | | Represents a second order 3D iso-parametric 19-node pyramid. | | The cell includes 5 corner nodes, 8 mid-edge nodes, 5 mid-face nodes, | and 1 volumetric centroid node. | | See also :vtk:`vtkTriQuadraticPyramid`. | | | VERTEX = <CellType.VERTEX: 1> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.Vertex | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Vertex-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`0D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 1 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>` | | Represents a point in 3D space. | | The vertex is a primary zero-dimensional cell. It is defined by a single point. | | See also :vtk:`vtkVertex`. | | | VOXEL = <CellType.VOXEL: 11> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.Voxel | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Voxel-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 8 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 12 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 6 <pyvista.CellType.n_faces>` | | Represents a 3D orthogonal parallelepiped. | | The voxel is a primary three-dimensional cell defined by an ordered list of | eight points. | | .. warning:: | This definition of a voxel differs from the conventional definition which | describes a single constant-valued volume element. The meaning of this | term can vary depending on context. See :ref:`image_representations_example` | for examples. | | See also :vtk:`vtkVoxel`. | | | WEDGE = <CellType.WEDGE: 13> | .. grid:: 1 2 2 2 | :reverse: | :margin: 1 | | .. grid-item:: | :columns: 12 4 4 4 | | .. card:: | :class-body: sd-px-0 sd-py-0 sd-rounded-3 | :link: pyvista.examples.cells.Wedge | :link-type: any | | .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Wedge-IMAGE-HASH-PLACEHOLDER_00_00.png | | .. grid-item:: | :columns: 12 8 8 8 | | :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>` | :bdg-link-muted:`Points: 6 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 9 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>` | | Represents a linear 3D wedge. | | The wedge is a primary three-dimensional cell consisting of two triangular | and three quadrilateral faces. | | See also :vtk:`vtkWedge`. | | | ---------------------------------------------------------------------- | Methods inherited from enum.IntEnum: | | __repr__(self) from enum.Enum | Return repr(self). | | __str__ = __repr__(self, /) from builtins.int | Return repr(self). | | ---------------------------------------------------------------------- | Methods inherited from builtins.int: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | True if self else False | | __ceil__(...) | Ceiling of an Integral returns itself. | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floor__(...) | Flooring an Integral returns itself. | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(self, /) | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __round__(...) | Rounding an Integral returns itself. | | Rounding with an ndigits argument also returns an integer. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __sizeof__(self, /) | Returns size in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __trunc__(...) | Truncating an Integral returns itself. | | __xor__(self, value, /) | Return self^value. | | as_integer_ratio(self, /) | Return a pair of integers, whose ratio is equal to the original int. | | The ratio is in lowest terms and has a positive denominator. | | >>> (10).as_integer_ratio() | (10, 1) | >>> (-10).as_integer_ratio() | (-10, 1) | >>> (0).as_integer_ratio() | (0, 1) | | bit_count(self, /) | Number of ones in the binary representation of the absolute value of self. | | Also known as the population count. | | >>> bin(13) | '0b1101' | >>> (13).bit_count() | 3 | | bit_length(self, /) | Number of bits necessary to represent self in binary. | | >>> bin(37) | '0b100101' | >>> (37).bit_length() | 6 | | conjugate(...) | Returns self, the complex conjugate of any int. | | is_integer(self, /) | Returns True. Exists for duck type compatibility with float.is_integer. | | to_bytes(self, /, length=1, byteorder='big', *, signed=False) | Return an array of bytes representing an integer. | | length | Length of bytes object to use. An OverflowError is raised if the | integer is not representable with the given number of bytes. Default | is length 1. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Determines whether two's complement is used to represent the integer. | If signed is False and a negative integer is given, an OverflowError | is raised. | | ---------------------------------------------------------------------- | Class methods inherited from builtins.int: | | from_bytes(bytes, byteorder='big', *, signed=False) | Return the integer represented by the given array of bytes. | | bytes | Holds the array of bytes to convert. The argument must either | support the buffer protocol or be an iterable object producing bytes. | Bytes and bytearray are examples of built-in objects that support the | buffer protocol. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Indicates whether two's complement is used to represent the integer. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.int: | | denominator | the denominator of a rational number in lowest terms | | imag | the imaginary part of a complex number | | numerator | the numerator of a rational number in lowest terms | | real | the real part of a complex number | | ---------------------------------------------------------------------- | Methods inherited from enum.Enum: | | __dir__(self) | Returns public methods and other interesting attributes. | | __init__(self, *args, **kwds) | Initialize self. See help(type(self)) for accurate signature. | | __reduce_ex__(self, proto) | Helper for pickle. | | ---------------------------------------------------------------------- | Data descriptors inherited from enum.Enum: | | name | The name of the Enum member. | | value | The value of the Enum member. | | ---------------------------------------------------------------------- | Static methods inherited from enum.EnumType: | | __contains__(value) | Return True if `value` is in `cls`. | | `value` is in `cls` if: | 1) `value` is a member of `cls`, or | 2) `value` is the value of one of the `cls`'s members. | | __getitem__(name) | Return the member matching `name`. | | __iter__() | Return members in definition order. | | __len__() | Return the number of members (no aliases) | | ---------------------------------------------------------------------- | Readonly properties inherited from enum.EnumType: | | __members__ | Returns a mapping of member name->value. | | This mapping lists all enum members, including aliases. Note that this | is a read-only view of the internal mapping.
pyvista.CellsLike
Python Library Documentation: _UnionGenericAlias in module typing
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
pyvista.Circle
Python Library Documentation: function Circle in module pyvista.core.utilities.geometric_objects
Circle(radius: 'float' = 0.5, resolution: 'int' = 100) -> 'PolyData'
Create a single PolyData circle defined by radius in the XY plane.
Parameters
----------
radius : float, default: 0.5
Radius of circle.
resolution : int, default: 100
Number of points on the circle.
Returns
-------
pyvista.PolyData
Circle mesh.
Notes
-----
.. versionchanged:: 0.38.0
Prior to version 0.38, this method had incorrect results, producing
inconsistent edge lengths and a duplicated point which is now fixed.
Examples
--------
>>> import pyvista as pv
>>> radius = 0.5
>>> circle = pv.Circle(radius=radius)
>>> circle.plot(show_edges=True, line_width=5)
pyvista.CircularArc
Python Library Documentation: function CircularArc in module pyvista.core.utilities.geometric_objects
CircularArc(pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int' = 100, negative: 'bool' = False) -> 'PolyData'
Create a circular arc defined by two endpoints and a center.
The number of segments composing the polyline is controlled by
setting the object resolution.
Parameters
----------
pointa : sequence[float]
Position of the first end point.
pointb : sequence[float]
Position of the other end point.
center : sequence[float]
Center of the circle that defines the arc.
resolution : int, default: 100
The number of segments of the polyline that draws the arc.
Resolution of 1 will just create a line.
negative : bool, default: False
By default the arc spans the shortest angular sector between
``pointa`` and ``pointb``.
By setting this to ``True``, the longest angular sector is
used instead (i.e. the negative coterminal angle to the
shortest one).
Returns
-------
pyvista.PolyData
Circular arc mesh.
Examples
--------
Create a quarter arc centered at the origin in the xy plane.
>>> import pyvista as pv
>>> arc = pv.CircularArc(pointa=[-1, 0, 0], pointb=[0, 1, 0], center=[0, 0, 0])
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(arc, color='k', line_width=10)
>>> _ = pl.show_bounds(location='all', font_size=30, use_2d=True)
>>> _ = pl.view_xy()
>>> pl.show()
See :ref:`create_circular_arc_example` and :ref:`flight_paths_example`
for more examples using this function.
pyvista.CircularArcFromNormal
Python Library Documentation: function CircularArcFromNormal in module pyvista.core.utilities.geometric_objects
CircularArcFromNormal(center: 'VectorLike[float]', resolution: 'int' = 100, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None) -> 'PolyData'
Create a circular arc defined by normal to the plane of the arc, and an angle.
The number of segments composing the polyline is controlled by
setting the object resolution.
Parameters
----------
center : sequence[float]
Center of the circle that defines the arc.
resolution : int, default: 100
The number of segments of the polyline that draws the arc.
Resolution of 1 will just create a line.
normal : sequence[float], optional
The normal vector to the plane of the arc. By default it
points in the positive Z direction.
polar : sequence[float], optional
Starting point of the arc in polar coordinates. By default it
is the unit vector in the positive x direction.
angle : float, optional
Arc length (in degrees) beginning at the polar vector. The
direction is counterclockwise. By default it is 90.
Returns
-------
pyvista.PolyData
Circular arc mesh.
Examples
--------
Quarter arc centered at the origin in the xy plane.
>>> import pyvista as pv
>>> normal = [0, 0, 1]
>>> polar = [-1, 0, 0]
>>> arc = pv.CircularArcFromNormal(
... center=[0, 0, 0], normal=normal, polar=polar
... )
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(arc, color='k', line_width=10)
>>> _ = pl.show_bounds(location='all', font_size=30, use_2d=True)
>>> _ = pl.view_xy()
>>> pl.show()
See :ref:`create_circular_arc_example` for more examples using this function.
pyvista.CompositeFilters
Python Library Documentation: class CompositeFilters in module pyvista.core.filters.composite
class CompositeFilters(pyvista.core.filters.data_object.DataObjectFilters)
| CompositeFilters(*args, **kwargs)
|
| An internal class to manage filters/algorithms for composite datasets.
|
| Method resolution order:
| CompositeFilters
| pyvista.core.filters.data_object.DataObjectFilters
| builtins.object
|
| Methods defined here:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| combine(self, merge_points: 'bool' = False, tolerance=0.0)
| Combine all blocks into a single unstructured grid.
|
| Parameters
| ----------
| merge_points : bool, default: False
| Merge coincidental points.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Combined blocks.
|
| Examples
| --------
| Combine blocks within a multiblock without merging points.
|
| >>> import pyvista as pv
| >>> block = pv.MultiBlock(
| ... [
| ... pv.Cube(clean=False),
| ... pv.Cube(center=(1, 0, 0), clean=False),
| ... ]
| ... )
| >>> merged = block.combine()
| >>> merged.n_points
| 48
|
| Combine blocks and merge points
|
| >>> merged = block.combine(merge_points=True)
| >>> merged.n_points
| 12
|
| extract_geometry(self)
| Extract the surface the geometry of all blocks.
|
| Place this filter at the end of a pipeline before a polydata
| consumer such as a polydata mapper to extract geometry from
| all blocks and append them to one polydata object.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the composite dataset.
|
| generic_filter(self: 'MultiBlock', function: 'str | Callable[..., _TypeMultiBlockLeaf]', /, *args, **kwargs) -> 'MultiBlock'
| Apply any filter to all nested blocks recursively.
|
| This filter applies a user-specified function or method to all blocks in
| this :class:`~pyvista.MultiBlock`.
|
| .. note::
|
| If an ``inplace`` keyword is used, this ``MultiBlock`` is modified
| in-place along with all blocks.
|
| .. note::
|
| By default, the specified ``function`` is not applied to any ``None``
| blocks. These are simply skipped and passed through to the output.
|
| For advanced use, it is possible to apply the filter to ``None`` blocks
| by using the undocumented keyword ``_skip_none=False``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| function : Callable | str
| Callable function or name of the method to apply to each block. The function
| should accept a :class:`~pyvista.DataSet` as input and return either a
| :class:`~pyvista.DataSet` or :class:`~pyvista.MultiBlock` as output.
|
| *args : Any, optional
| Arguments to use with the specified ``function``.
|
| **kwargs : Any, optional
| Keyword arguments to use with the specified ``function``.
|
| Returns
| -------
| MultiBlock
| Filtered dataset.
|
| Raises
| ------
| RuntimeError
| Raised if the filter cannot be applied to any block for any reason. This
| overrides ``TypeError``, ``ValueError``, ``AttributeError`` errors when
| filtering.
|
| See Also
| --------
| pyvista.MultiBlock.flatten
| pyvista.MultiBlock.recursive_iterator
| pyvista.MultiBlock.clean
|
| Examples
| --------
| Create a :class:`~pyvista.MultiBlock` with various mesh types.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> volume = examples.load_uniform()
| >>> poly = examples.load_ant()
| >>> unstructured = examples.load_tetbeam()
| >>> multi = pv.MultiBlock([volume, poly, unstructured])
|
| >>> [type(block) for block in multi] # doctest: +NORMALIZE_WHITESPACE
| [<class 'pyvista.core.grid.ImageData'>,
| <class 'pyvista.core.pointset.PolyData'>,
| <class 'pyvista.core.pointset.UnstructuredGrid'>]
|
| Use the generic filter to apply :meth:`~pyvista.DataSet.cast_to_unstructured_grid`
| to all blocks.
|
| >>> filtered = multi.generic_filter('cast_to_unstructured_grid')
|
| >>> [type(block) for block in filtered] # doctest: +NORMALIZE_WHITESPACE
| [<class 'pyvista.core.pointset.UnstructuredGrid'>,
| <class 'pyvista.core.pointset.UnstructuredGrid'>,
| <class 'pyvista.core.pointset.UnstructuredGrid'>]
|
| Use the :meth:`~pyvista.DataSetFilters.partition` filter on all blocks.
| Any arguments can be specified as though the filter is being used directly.
|
| >>> filtered = multi.generic_filter('partition', 4, as_composite=True)
|
| Any function can be used as long as it returns a :class:`~pyvista.DataSet` or
| :class:`~pyvista.MultiBlock`. For example, we can normalize each block
| independently to have bounds between ``-0.5`` and ``0.5``.
|
| >>> def normalize_bounds(dataset):
| ... # Center the dataset
| ... dataset = dataset.translate(-np.array(dataset.center))
| ... # Scale the dataset
| ... factor = 1 / np.array(dataset.bounds_size)
| ... return dataset.scale(factor)
|
| >>> filtered = multi.generic_filter(normalize_bounds)
| >>> filtered
| MultiBlock (...)
| N Blocks: 3
| X Bounds: -5.000e-01, 5.000e-01
| Y Bounds: -5.000e-01, 5.000e-01
| Z Bounds: -5.000e-01, 5.000e-01
|
| The generic filter will fail if the filter can only be applied to some blocks
| but not others. For example, it is not possible to use the
| :meth:`~pyvista.ImageDataFilters.resample` filter generically since the
| ``MultiBlock`` above is heterogeneous and contains some blocks which are not
| :class:`~pyvista.ImageData`.
|
| >>> multi.generic_filter('resample', 0.5) # doctest:+SKIP
| RuntimeError: The filter 'resample' could not be applied to the block at index 1 with
| name 'Block-01' and type PolyData.
|
| Use a custom function instead to apply the generic filter conditionally. Here we
| filter the image blocks but simply pass-through a copy of any other blocks.
|
| >>> def conditional_resample(dataset, *args, **kwargs):
| ... if isinstance(dataset, pv.ImageData):
| ... return dataset.resample(*args, **kwargs)
| ... return dataset.copy()
|
| >>> filtered = multi.generic_filter(conditional_resample, 0.5)
|
| outline(self: 'MultiBlock', generate_faces: 'bool' = False, nested: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the all blocks in this composite dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box.
|
| nested : bool, default: False
| If ``True``, these creates individual outlines for each nested dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the outline.
|
| outline_corners(self: 'MultiBlock', factor=0.2, nested: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the corners for the all blocks in this composite dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| nested : bool, default: False
| If ``True``, these creates individual outlines for each nested dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
pyvista.Cone
Python Library Documentation: function Cone in module pyvista.core.utilities.geometric_objects
Cone(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0), height: 'float' = 1.0, radius: 'float | None' = None, capping: 'bool' = True, angle: 'float | None' = None, resolution: 'int' = 6) -> 'PolyData'
Create a cone.
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Center in ``[x, y, z]``. Axis of the cone passes through this
point.
direction : sequence[float], default: (1.0, 0.0, 0.0)
Direction vector in ``[x, y, z]``. Orientation vector of the
cone.
height : float, default: 1.0
Height along the cone in its specified direction.
radius : float, optional
Base radius of the cone.
capping : bool, optional
Enable or disable the capping the base of the cone with a
polygon.
angle : float, optional
The angle in degrees between the axis of the cone and a
generatrix.
resolution : int, default: 6
Number of facets used to represent the cone.
Returns
-------
pyvista.PolyData
Cone mesh.
Examples
--------
Create a default Cone.
>>> import pyvista as pv
>>> mesh = pv.Cone()
>>> mesh.plot(show_edges=True, line_width=5)
pyvista.ConeSource
Python Library Documentation: class ConeSource in module pyvista.core.utilities.geometric_sources
class ConeSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkConeSource)
| ConeSource(*args, **kwargs) -> '_T'
|
| Cone source algorithm class.
|
| Parameters
| ----------
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Center in ``[x, y, z]``. Axis of the cone passes through this
| point.
|
| direction : sequence[float], default: (1.0, 0.0, 0.0)
| Direction vector in ``[x, y, z]``. Orientation vector of the
| cone.
|
| height : float, default: 1.0
| Height along the cone in its specified direction.
|
| radius : float, optional
| Base radius of the cone.
|
| capping : bool, default: True
| Enable or disable the capping the base of the cone with a
| polygon.
|
| angle : float, optional
| The angle in degrees between the axis of the cone and a
| generatrix.
|
| resolution : int, default: 6
| Number of facets used to represent the cone.
|
| Examples
| --------
| Create a default ConeSource.
|
| >>> import pyvista as pv
| >>> source = pv.ConeSource()
| >>> source.output.plot(show_edges=True, line_width=5)
|
| Method resolution order:
| ConeSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkConeSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'ConeSource', center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0), height: 'float' = 1.0, radius: 'float | None' = None, capping: 'bool' = True, angle: 'float | None' = None, resolution: 'int' = 6) -> 'None'
| Initialize the cone source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Cone surface.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| angle
| Get the angle in degrees between the axis of the cone and a generatrix.
|
| Returns
| -------
| float
| The angle in degrees between the axis of the cone and a
| generatrix.
|
| capping
| Enable or disable the capping the base of the cone with a polygon.
|
| Returns
| -------
| bool
| Enable or disable the capping the base of the cone with a
| polygon.
|
| center
| Get the center in ``[x, y, z]``. Axis of the cone passes through this point.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``. Axis of the cone passes through this
| point.
|
| direction
| Get the direction vector in ``[x, y, z]``. Orientation vector of the cone.
|
| Returns
| -------
| sequence[float]
| Direction vector in ``[x, y, z]``. Orientation vector of the
| cone.
|
| height
| Get the height along the cone in its specified direction.
|
| Returns
| -------
| float
| Height along the cone in its specified direction.
|
| radius
| Get base radius of the cone.
|
| Returns
| -------
| float
| Base radius of the cone.
|
| resolution
| Get number of points on the circular face of the cone.
|
| Returns
| -------
| int
| Number of points on the circular face of the cone.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkConeSource:
|
| CappingOff(...)
| CappingOff(self) -> None
| C++: virtual void CappingOff()
|
| CappingOn(...)
| CappingOn(self) -> None
| C++: virtual void CappingOn()
|
| GetAngle(...)
| GetAngle(self) -> float
| C++: double GetAngle()
|
| GetCapping(...)
| GetCapping(self) -> int
| C++: virtual vtkTypeBool GetCapping()
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetDirection(...)
| GetDirection(self) -> (float, float, float)
| C++: virtual double *GetDirection()
|
| GetHeight(...)
| GetHeight(self) -> float
| C++: virtual double GetHeight()
|
| GetHeightMaxValue(...)
| GetHeightMaxValue(self) -> float
| C++: virtual double GetHeightMaxValue()
|
| GetHeightMinValue(...)
| GetHeightMinValue(self) -> float
| C++: virtual double GetHeightMinValue()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetRadius(...)
| GetRadius(self) -> float
| C++: virtual double GetRadius()
|
| GetRadiusMaxValue(...)
| GetRadiusMaxValue(self) -> float
| C++: virtual double GetRadiusMaxValue()
|
| GetRadiusMinValue(...)
| GetRadiusMinValue(self) -> float
| C++: virtual double GetRadiusMinValue()
|
| GetResolution(...)
| GetResolution(self) -> int
| C++: virtual int GetResolution()
|
| GetResolutionMaxValue(...)
| GetResolutionMaxValue(self) -> int
| C++: virtual int GetResolutionMaxValue()
|
| GetResolutionMinValue(...)
| GetResolutionMinValue(self) -> int
| C++: virtual int GetResolutionMinValue()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkConeSource
| C++: vtkConeSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkConeSource
| C++: static vtkConeSource *SafeDownCast(vtkObjectBase *o)
|
| SetAngle(...)
| SetAngle(self, angle:float) -> None
| C++: void SetAngle(double angle)
|
| Set the angle of the cone. This is the angle between the axis of
| the cone and a generatrix. Warning: this is not the aperture! The
| aperture is twice this angle. As a side effect, the angle plus
| height sets the base radius of the cone. Angle is expressed in
| degrees.
|
| SetCapping(...)
| SetCapping(self, _arg:int) -> None
| C++: virtual void SetCapping(vtkTypeBool _arg)
|
| Turn on/off whether to cap the base of the cone with a polygon.
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set the center of the cone. It is located at the middle of the
| axis of the cone. Warning: this is not the center of the base of
| the cone! The default is 0,0,0.
|
| SetDirection(...)
| SetDirection(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetDirection(double _arg1, double _arg2,
| double _arg3)
| SetDirection(self, _arg:(float, float, float)) -> None
| C++: virtual void SetDirection(const double _arg[3])
|
| Set the orientation vector of the cone. The vector does not have
| to be normalized. The direction goes from the center of the base
| toward the apex. The default is (1,0,0).
|
| SetHeight(...)
| SetHeight(self, _arg:float) -> None
| C++: virtual void SetHeight(double _arg)
|
| Set the height of the cone. This is the height along the cone in
| its specified direction.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetRadius(...)
| SetRadius(self, _arg:float) -> None
| C++: virtual void SetRadius(double _arg)
|
| Set the base radius of the cone.
|
| SetResolution(...)
| SetResolution(self, _arg:int) -> None
| C++: virtual void SetResolution(int _arg)
|
| Set the number of facets used to represent the cone.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkConeSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkConeSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkConeSource:
|
| __this__
| Pointer to the C++ object.
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkConeSource:
|
| __vtkname__ = 'vtkConeSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.Cube
Python Library Documentation: function Cube in module pyvista.core.utilities.geometric_objects
Cube(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), x_length: 'float' = 1.0, y_length: 'float' = 1.0, z_length: 'float' = 1.0, bounds: 'VectorLike[float] | None' = None, clean: 'bool' = True, point_dtype: 'str' = 'float32') -> 'PolyData'
Create a cube.
It's possible to specify either the center and side lengths or
just the bounds of the cube. If ``bounds`` are given, all other
arguments are ignored.
.. versionchanged:: 0.33.0
The cube is created using :vtk:`vtkCubeSource`. For
compatibility with :func:`pyvista.PlatonicSolid`, face indices
are also added as cell data. For full compatibility with
:func:`~pyvista.PlatonicSolid`, one has to
use ``x_length = y_length = z_length = 2 * radius / 3**0.5``.
The cube points are also cleaned by default now, leaving only
the 8 corners and a watertight (manifold) mesh.
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Center in ``[x, y, z]``.
x_length : float, default: 1.0
Length of the cube in the x-direction.
y_length : float, default: 1.0
Length of the cube in the y-direction.
z_length : float, default: 1.0
Length of the cube in the z-direction.
bounds : sequence[float], optional
Specify the bounding box of the cube. If given, all other size
arguments are ignored. ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
clean : bool, default: True
Whether to clean the raw points of the mesh, making the cube
manifold. Note that this will degrade the texture coordinates
that come with the mesh, so if you plan to map a texture on
the cube, consider setting this to ``False``.
.. versionadded:: 0.33.0
point_dtype : str, default: 'float32'
Set the desired output point types. It must be either 'float32' or 'float64'.
.. versionadded:: 0.44.0
Returns
-------
pyvista.PolyData
Mesh of the cube.
Examples
--------
Create a default cube.
>>> import pyvista as pv
>>> mesh = pv.Cube()
>>> mesh.plot(show_edges=True, line_width=5)
pyvista.CubeFacesSource
Python Library Documentation: class CubeFacesSource in module pyvista.core.utilities.geometric_sources
class CubeFacesSource(CubeSource)
| CubeFacesSource(*args, **kwargs) -> '_T'
|
| Generate the faces of a cube.
|
| This source generates a :class:`~pyvista.MultiBlock` with the six :class:`PolyData`
| comprising the faces of a cube.
|
| The faces may be shrunk or exploded to create equal-sized gaps or intersections
| between the faces. Additionally, the faces may be converted to frames with a
| constant-width border.
|
| .. versionadded:: 0.45.0
|
| Parameters
| ----------
| center : VectorLike[float], default: (0.0, 0.0, 0.0)
| Center in ``[x, y, z]``.
|
| x_length : float, default: 1.0
| Length of the cube in the x-direction.
|
| y_length : float, default: 1.0
| Length of the cube in the y-direction.
|
| z_length : float, default: 1.0
| Length of the cube in the z-direction.
|
| bounds : sequence[float], optional
| Specify the bounding box of the cube. If given, all other size
| arguments are ignored. ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| frame_width : float, optional
| Convert the faces into frames with the specified width. If set, the center
| portion of each face is removed and the output faces will each have four quad
| cells (one for each side of the frame) instead of a single quad cell. Values
| must be between ``0.0`` (minimal frame) and ``1.0`` (large frame). The frame is
| scaled to ensure it has a constant width.
|
| shrink_factor : float, optional
| Shrink or grow the cube's faces. If set, this is the factor by which to shrink
| or grow each face. The amount of shrinking or growth is relative to the smallest
| edge length of the cube, and all sides of the faces are shrunk by the same
| (constant) value.
|
| .. note::
| - A value of ``1.0`` has no effect.
| - Values between ``0.0`` and ``1.0`` will shrink the faces.
| - Values greater than ``1.0`` will grow the faces.
|
| This has a similar effect to using :meth:`~pyvista.DataSetFilters.shrink`.
|
| explode_factor : float, optional
| Push the faces away from (or pull them toward) the cube's center. If set, this
| is the factor by which to move each face. The magnitude of the move is relative
| to the smallest edge length of the cube, and all faces are moved by the same
| (constant) amount.
|
| .. note::
| - A value of ``0.0`` has no effect.
| - Increasing positive values will push the faces farther away (explode).
| - Decreasing negative values will pull the faces closer together (implode).
|
| This has a similar effect to using :meth:`~pyvista.DataSetFilters.explode`.
|
| names : sequence[str], default: ('+X','-X','+Y','-Y','+Z','-Z')
| Name of each face in the generated :class:`~pyvista.MultiBlock`.
|
| point_dtype : str, default: 'float32'
| Set the desired output point types. It must be either 'float32' or 'float64'.
|
| Examples
| --------
| Generate the default faces of a cube.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> cube_faces_source = pv.CubeFacesSource()
| >>> output = cube_faces_source.output
| >>> output.plot(show_edges=True, line_width=10)
|
| The output is similar to that of :class:`CubeSource` except it's a
| :class:`~pyvista.MultiBlock`.
|
| >>> output
| MultiBlock (...)
| N Blocks: 6
| X Bounds: -5.000e-01, 5.000e-01
| Y Bounds: -5.000e-01, 5.000e-01
| Z Bounds: -5.000e-01, 5.000e-01
|
| >>> cube_source = pv.CubeSource()
| >>> cube_source.output
| PolyData (...)
| N Cells: 6
| N Points: 24
| N Strips: 0
| X Bounds: -5.000e-01, 5.000e-01
| Y Bounds: -5.000e-01, 5.000e-01
| Z Bounds: -5.000e-01, 5.000e-01
| N Arrays: 2
|
| Use :attr:`explode_factor` to explode the faces.
|
| >>> cube_faces_source.explode_factor = 0.5
| >>> cube_faces_source.update()
| >>> output.plot(show_edges=True, line_width=10)
|
| Use :attr:`shrink_factor` to also shrink the faces.
|
| >>> cube_faces_source.shrink_factor = 0.5
| >>> cube_faces_source.update()
| >>> output.plot(show_edges=True, line_width=10)
|
| Fit cube faces to a dataset and only plot four of them.
|
| >>> mesh = examples.load_airplane()
| >>> cube_faces_source = pv.CubeFacesSource(bounds=mesh.bounds)
| >>> output = cube_faces_source.output
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='tomato')
| >>> _ = pl.add_mesh(output['+X'], opacity=0.5)
| >>> _ = pl.add_mesh(output['-X'], opacity=0.5)
| >>> _ = pl.add_mesh(output['+Y'], opacity=0.5)
| >>> _ = pl.add_mesh(output['-Y'], opacity=0.5)
| >>> pl.show()
|
| Generate a frame instead of full faces.
|
| >>> mesh = pv.ParametricEllipsoid(5, 4, 3)
| >>> cube_faces_source = pv.CubeFacesSource(bounds=mesh.bounds, frame_width=0.1)
| >>> output = cube_faces_source.output
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='tomato')
| >>> _ = pl.add_mesh(output, show_edges=True, line_width=10)
| >>> pl.show()
|
| Method resolution order:
| CubeFacesSource
| CubeSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkCubeSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'CubeFacesSource', *, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), x_length: 'float' = 1.0, y_length: 'float' = 1.0, z_length: 'float' = 1.0, bounds: 'VectorLike[float] | None' = None, frame_width: 'float | None' = None, shrink_factor: 'float | None' = None, explode_factor: 'float | None' = None, names: 'Sequence[str]' = ('+X', '-X', '+Y', '-Y', '+Z', '-Z'), point_dtype: 'str' = 'float32') -> 'None'
| Initialize the cube source class.
|
| update(self: 'CubeFacesSource') -> 'None'
| Update the output of the source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output of the source.
|
| The output is a :class:`pyvista.MultiBlock` with six blocks: one for each
| face. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The source is automatically updated by :meth:`update` prior to returning
| the output.
|
| Returns
| -------
| pyvista.MultiBlock
| Composite mesh with six cube faces.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| explode_factor
| Push the faces away from (or pull them toward) the cube's center.
|
| If set, this is the factor by which to move each face. The magnitude of the
| move is relative to the smallest edge length of the cube, and all faces are
| moved by the same (constant) amount.
|
| .. note::
| - A value of ``0.0`` has no effect.
| - Increasing positive values will push the faces farther away (explode).
| - Decreasing negative values will pull the faces closer together (implode).
|
| This has a similar effect to using :meth:`~pyvista.DataSetFilters.explode`.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> cube_faces_source = pv.CubeFacesSource(
| ... x_length=3, y_length=2, z_length=1, explode_factor=0.2
| ... )
| >>> output = cube_faces_source.output
| >>> output.plot(show_edges=True, line_width=10)
|
| Note how all faces are moved by the same amount. Compare this to using
| :meth:`~pyvista.DataSetFilters.explode` where the distance each face moves
| is relative to distance of each face to the center of the cube.
|
| >>> exploded = pv.merge(output).explode(0.2)
| >>> exploded.plot(show_edges=True, line_width=10)
|
| frame_width
| Convert the faces into frames with the specified border width.
|
| If set, the center portion of each face is removed and the :attr:`output`
| :class:`pyvista.PolyData` will each have four quad cells (one for each
| side of the frame) instead of a single quad cell. Values must be between ``0.0``
| (minimal frame) and ``1.0`` (large frame). The frame is scaled to ensure it has
| a constant width.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> cube_faces_source = pv.CubeFacesSource(
| ... x_length=3, y_length=2, z_length=1, frame_width=0.2
| ... )
| >>> cube_faces_source.output.plot(show_edges=True, line_width=10)
|
| >>> cube_faces_source.frame_width = 0.8
| >>> cube_faces_source.output.plot(show_edges=True, line_width=10)
|
| names
| Return or set the names of the faces.
|
| Specify three strings, one for each '+/-' face pair, or six strings, one for
| each individual face.
|
| If three strings, plus ``'+'`` and minus ``'-'`` characters are added to
| the names.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> cube_faces = pv.CubeFacesSource()
|
| Use three strings to set the names. Plus ``'+'`` and minus ``'-'``
| characters are added automatically.
|
| >>> cube_faces.names = ['U', 'V', 'W']
| >>> cube_faces.names
| ('+U', '-U', '+V', '-V', '+W', '-W')
|
| Alternatively, use six strings to set the names explicitly.
|
| >>> cube_faces.names = [
| ... 'right',
| ... 'left',
| ... 'anterior',
| ... 'posterior',
| ... 'superior',
| ... 'inferior',
| ... ]
| >>> cube_faces.names
| ('right', 'left', 'anterior', 'posterior', 'superior', 'inferior')
|
| shrink_factor
| Shrink or grow the cube's faces.
|
| If set, this is the factor by which to shrink or grow each face. The amount of
| shrinking or growth is relative to the smallest edge length of the cube, and
| all sides of the faces are shrunk by the same (constant) value.
|
| .. note::
| - A value of ``1.0`` has no effect.
| - Values between ``0.0`` and ``1.0`` will shrink the faces.
| - Values greater than ``1.0`` will grow the faces.
|
| This has a similar effect to using :meth:`~pyvista.DataSetFilters.shrink`.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> cube_faces_source = pv.CubeFacesSource(
| ... x_length=3, y_length=2, z_length=1, shrink_factor=0.8
| ... )
| >>> output = cube_faces_source.output
| >>> output.plot(show_edges=True, line_width=10)
|
| Note how all edges are shrunk by the same (constant) amount in terms of absolute
| distance. Compare this to :meth:`~pyvista.DataSetFilters.shrink` where the
| amount of shrinkage is relative to the size of the faces.
|
| >>> exploded = pv.merge(output).shrink(0.8)
| >>> exploded.plot(show_edges=True, line_width=10)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from CubeSource:
|
| bounds
| Return or set the bounding box of the cube.
|
| center
| Get the center in ``[x, y, z]``.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``.
|
| point_dtype
| Get the desired output point types.
|
| Returns
| -------
| str
| Desired output point types.
| It must be either 'float32' or 'float64'.
|
| x_length
| Get the x length along the cube in its specified direction.
|
| Returns
| -------
| float
| XLength along the cone in its specified direction.
|
| y_length
| Get the y length along the cube in its specified direction.
|
| Returns
| -------
| float
| YLength along the cone in its specified direction.
|
| z_length
| Get the z length along the cube in its specified direction.
|
| Returns
| -------
| float
| ZLength along the cone in its specified direction.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| GetBounds(...)
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetXLength(...)
| GetXLength(self) -> float
| C++: virtual double GetXLength()
|
| GetXLengthMaxValue(...)
| GetXLengthMaxValue(self) -> float
| C++: virtual double GetXLengthMaxValue()
|
| GetXLengthMinValue(...)
| GetXLengthMinValue(self) -> float
| C++: virtual double GetXLengthMinValue()
|
| GetYLength(...)
| GetYLength(self) -> float
| C++: virtual double GetYLength()
|
| GetYLengthMaxValue(...)
| GetYLengthMaxValue(self) -> float
| C++: virtual double GetYLengthMaxValue()
|
| GetYLengthMinValue(...)
| GetYLengthMinValue(self) -> float
| C++: virtual double GetYLengthMinValue()
|
| GetZLength(...)
| GetZLength(self) -> float
| C++: virtual double GetZLength()
|
| GetZLengthMaxValue(...)
| GetZLengthMaxValue(self) -> float
| C++: virtual double GetZLengthMaxValue()
|
| GetZLengthMinValue(...)
| GetZLengthMinValue(self) -> float
| C++: virtual double GetZLengthMinValue()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkCubeSource
| C++: vtkCubeSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkCubeSource
| C++: static vtkCubeSource *SafeDownCast(vtkObjectBase *o)
|
| SetBounds(...)
| SetBounds(self, xMin:float, xMax:float, yMin:float, yMax:float,
| zMin:float, zMax:float) -> None
| C++: void SetBounds(double xMin, double xMax, double yMin,
| double yMax, double zMin, double zMax)
| SetBounds(self, bounds:(float, float, float, float, float, float))
| -> None
| C++: void SetBounds(const double bounds[6])
|
| Convenience methods allows creation of cube by specifying
| bounding box.
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set the center of the cube.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetXLength(...)
| SetXLength(self, _arg:float) -> None
| C++: virtual void SetXLength(double _arg)
|
| Set the length of the cube in the x-direction.
|
| SetYLength(...)
| SetYLength(self, _arg:float) -> None
| C++: virtual void SetYLength(double _arg)
|
| Set the length of the cube in the y-direction.
|
| SetZLength(...)
| SetZLength(self, _arg:float) -> None
| C++: virtual void SetZLength(double _arg)
|
| Set the length of the cube in the z-direction.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkCubeSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| __this__
| Pointer to the C++ object.
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| __vtkname__ = 'vtkCubeSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.CubeSource
Python Library Documentation: class CubeSource in module pyvista.core.utilities.geometric_sources
class CubeSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkCubeSource)
| CubeSource(*args, **kwargs) -> '_T'
|
| Cube source algorithm class.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Center in ``[x, y, z]``.
|
| x_length : float, default: 1.0
| Length of the cube in the x-direction.
|
| y_length : float, default: 1.0
| Length of the cube in the y-direction.
|
| z_length : float, default: 1.0
| Length of the cube in the z-direction.
|
| bounds : sequence[float], optional
| Specify the bounding box of the cube. If given, all other size
| arguments are ignored. ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| point_dtype : str, default: 'float32'
| Set the desired output point types. It must be either 'float32' or 'float64'.
|
| .. versionadded:: 0.44.0
|
| Examples
| --------
| Create a default CubeSource.
|
| >>> import pyvista as pv
| >>> source = pv.CubeSource()
| >>> source.output.plot(show_edges=True, line_width=5)
|
| Method resolution order:
| CubeSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkCubeSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'CubeSource', center: 'VectorLike[float]' = (0.0, 0.0, 0.0), x_length: 'float' = 1.0, y_length: 'float' = 1.0, z_length: 'float' = 1.0, bounds: 'VectorLike[float] | None' = None, point_dtype: 'str' = 'float32') -> 'None'
| Initialize the cube source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Cube surface.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| bounds
| Return or set the bounding box of the cube.
|
| center
| Get the center in ``[x, y, z]``.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``.
|
| point_dtype
| Get the desired output point types.
|
| Returns
| -------
| str
| Desired output point types.
| It must be either 'float32' or 'float64'.
|
| x_length
| Get the x length along the cube in its specified direction.
|
| Returns
| -------
| float
| XLength along the cone in its specified direction.
|
| y_length
| Get the y length along the cube in its specified direction.
|
| Returns
| -------
| float
| YLength along the cone in its specified direction.
|
| z_length
| Get the z length along the cube in its specified direction.
|
| Returns
| -------
| float
| ZLength along the cone in its specified direction.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| GetBounds(...)
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetXLength(...)
| GetXLength(self) -> float
| C++: virtual double GetXLength()
|
| GetXLengthMaxValue(...)
| GetXLengthMaxValue(self) -> float
| C++: virtual double GetXLengthMaxValue()
|
| GetXLengthMinValue(...)
| GetXLengthMinValue(self) -> float
| C++: virtual double GetXLengthMinValue()
|
| GetYLength(...)
| GetYLength(self) -> float
| C++: virtual double GetYLength()
|
| GetYLengthMaxValue(...)
| GetYLengthMaxValue(self) -> float
| C++: virtual double GetYLengthMaxValue()
|
| GetYLengthMinValue(...)
| GetYLengthMinValue(self) -> float
| C++: virtual double GetYLengthMinValue()
|
| GetZLength(...)
| GetZLength(self) -> float
| C++: virtual double GetZLength()
|
| GetZLengthMaxValue(...)
| GetZLengthMaxValue(self) -> float
| C++: virtual double GetZLengthMaxValue()
|
| GetZLengthMinValue(...)
| GetZLengthMinValue(self) -> float
| C++: virtual double GetZLengthMinValue()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkCubeSource
| C++: vtkCubeSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkCubeSource
| C++: static vtkCubeSource *SafeDownCast(vtkObjectBase *o)
|
| SetBounds(...)
| SetBounds(self, xMin:float, xMax:float, yMin:float, yMax:float,
| zMin:float, zMax:float) -> None
| C++: void SetBounds(double xMin, double xMax, double yMin,
| double yMax, double zMin, double zMax)
| SetBounds(self, bounds:(float, float, float, float, float, float))
| -> None
| C++: void SetBounds(const double bounds[6])
|
| Convenience methods allows creation of cube by specifying
| bounding box.
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set the center of the cube.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetXLength(...)
| SetXLength(self, _arg:float) -> None
| C++: virtual void SetXLength(double _arg)
|
| Set the length of the cube in the x-direction.
|
| SetYLength(...)
| SetYLength(self, _arg:float) -> None
| C++: virtual void SetYLength(double _arg)
|
| Set the length of the cube in the y-direction.
|
| SetZLength(...)
| SetZLength(self, _arg:float) -> None
| C++: virtual void SetZLength(double _arg)
|
| Set the length of the cube in the z-direction.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkCubeSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| __this__
| Pointer to the C++ object.
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| __vtkname__ = 'vtkCubeSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.Cylinder
Python Library Documentation: function Cylinder in module pyvista.core.utilities.geometric_objects
Cylinder(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0), radius: 'float' = 0.5, height: 'float' = 1.0, resolution: 'int' = 100, capping: 'bool' = True) -> 'PolyData'
Create the surface of a cylinder.
.. warning::
:func:`pyvista.Cylinder` function rotates the :class:`pyvista.CylinderSource` 's
:class:`pyvista.PolyData` in its own way.
It rotates the :attr:`pyvista.CylinderSource.output` 90 degrees in z-axis, translates and
orients the mesh to a new ``center`` and ``direction``.
See also :func:`pyvista.CylinderStructured`.
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Location of the centroid in ``[x, y, z]``.
direction : sequence[float], default: (1.0, 0.0, 0.0)
Direction cylinder points to in ``[x, y, z]``.
radius : float, default: 0.5
Radius of the cylinder.
height : float, default: 1.0
Height of the cylinder.
resolution : int, default: 100
Number of points on the circular face of the cylinder.
capping : bool, default: True
Cap cylinder ends with polygons.
Returns
-------
pyvista.PolyData
Cylinder surface.
Examples
--------
>>> import pyvista as pv
>>> cylinder = pv.Cylinder(
... center=[1, 2, 3], direction=[1, 1, 1], radius=1, height=2
... )
>>> cylinder.plot(show_edges=True, line_width=5, cpos='xy')
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(
... pv.Cylinder(center=[1, 2, 3], direction=[1, 1, 1], radius=1, height=2),
... show_edges=True,
... line_width=5,
... )
>>> pl.camera_position = 'xy'
>>> pl.show()
The above examples are similar in terms of their behavior.
See :ref:`chemistry_molecule_example` for more examples using this function.
pyvista.CylinderSource
Python Library Documentation: class CylinderSource in module pyvista.core.utilities.geometric_sources
class CylinderSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkCylinderSource)
| CylinderSource(*args, **kwargs) -> '_T'
|
| Cylinder source algorithm class.
|
| .. warning::
| :func:`pyvista.Cylinder` function rotates the :class:`pyvista.CylinderSource` 's
| :class:`pyvista.PolyData` in its own way.
| It rotates the :attr:`pyvista.CylinderSource.output` 90 degrees in z-axis, translates and
| orients the mesh to a new ``center`` and ``direction``.
|
| Parameters
| ----------
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Location of the centroid in ``[x, y, z]``.
|
| direction : sequence[float], default: (1.0, 0.0, 0.0)
| Direction cylinder points to in ``[x, y, z]``.
|
| radius : float, default: 0.5
| Radius of the cylinder.
|
| height : float, default: 1.0
| Height of the cylinder.
|
| capping : bool, default: True
| Cap cylinder ends with polygons.
|
| resolution : int, default: 100
| Number of points on the circular face of the cylinder.
|
| Examples
| --------
| Create a default CylinderSource.
|
| >>> import pyvista as pv
| >>> source = pv.CylinderSource()
| >>> source.output.plot(show_edges=True, line_width=5)
|
| Display a 3D plot of a default :class:`CylinderSource`.
|
| >>> import pyvista as pv
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pv.CylinderSource(), show_edges=True, line_width=5)
| >>> pl.show()
|
| Visualize the output of :class:`CylinderSource` in a 3D plot.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pv.CylinderSource().output, show_edges=True, line_width=5)
| >>> pl.show()
|
| The above examples are similar in terms of their behavior.
|
| Method resolution order:
| CylinderSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkCylinderSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'CylinderSource', center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0), radius: 'float' = 0.5, height: 'float' = 1.0, capping: 'bool' = True, resolution: 'int' = 100) -> 'None'
| Initialize the cylinder source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Cylinder surface.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| capping
| Get cap cylinder ends with polygons.
|
| Returns
| -------
| bool
| Cap cylinder ends with polygons.
|
| capsule_cap
| Get whether the capping should make the cylinder a capsule.
|
| .. versionadded:: 0.44.0
|
| Returns
| -------
| bool
| Capsule cap.
|
| center
| Get location of the centroid in ``[x, y, z]``.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``. Axis of the cylinder passes through this
| point.
|
| direction
| Get the direction vector in ``[x, y, z]``. Orientation vector of the cylinder.
|
| Returns
| -------
| sequence[float]
| Direction vector in ``[x, y, z]``. Orientation vector of the
| cylinder.
|
| height
| Get the height of the cylinder.
|
| Returns
| -------
| float
| Height of the cylinder.
|
| radius
| Get radius of the cylinder.
|
| Returns
| -------
| float
| Radius of the cylinder.
|
| resolution
| Get number of points on the circular face of the cylinder.
|
| Returns
| -------
| int
| Number of points on the circular face of the cone.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkCylinderSource:
|
| CappingOff(...)
| CappingOff(self) -> None
| C++: virtual void CappingOff()
|
| CappingOn(...)
| CappingOn(self) -> None
| C++: virtual void CappingOn()
|
| CapsuleCapOff(...)
| CapsuleCapOff(self) -> None
| C++: virtual void CapsuleCapOff()
|
| CapsuleCapOn(...)
| CapsuleCapOn(self) -> None
| C++: virtual void CapsuleCapOn()
|
| GetCapping(...)
| GetCapping(self) -> int
| C++: virtual vtkTypeBool GetCapping()
|
| GetCapsuleCap(...)
| GetCapsuleCap(self) -> int
| C++: virtual vtkTypeBool GetCapsuleCap()
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetHeight(...)
| GetHeight(self) -> float
| C++: virtual double GetHeight()
|
| GetHeightMaxValue(...)
| GetHeightMaxValue(self) -> float
| C++: virtual double GetHeightMaxValue()
|
| GetHeightMinValue(...)
| GetHeightMinValue(self) -> float
| C++: virtual double GetHeightMinValue()
|
| GetLatLongTessellation(...)
| GetLatLongTessellation(self) -> int
| C++: virtual vtkTypeBool GetLatLongTessellation()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetRadius(...)
| GetRadius(self) -> float
| C++: virtual double GetRadius()
|
| GetRadiusMaxValue(...)
| GetRadiusMaxValue(self) -> float
| C++: virtual double GetRadiusMaxValue()
|
| GetRadiusMinValue(...)
| GetRadiusMinValue(self) -> float
| C++: virtual double GetRadiusMinValue()
|
| GetResolution(...)
| GetResolution(self) -> int
| C++: virtual int GetResolution()
|
| GetResolutionMaxValue(...)
| GetResolutionMaxValue(self) -> int
| C++: virtual int GetResolutionMaxValue()
|
| GetResolutionMinValue(...)
| GetResolutionMinValue(self) -> int
| C++: virtual int GetResolutionMinValue()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| LatLongTessellationOff(...)
| LatLongTessellationOff(self) -> None
| C++: virtual void LatLongTessellationOff()
|
| LatLongTessellationOn(...)
| LatLongTessellationOn(self) -> None
| C++: virtual void LatLongTessellationOn()
|
| NewInstance(...)
| NewInstance(self) -> vtkCylinderSource
| C++: vtkCylinderSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkCylinderSource
| C++: static vtkCylinderSource *SafeDownCast(vtkObjectBase *o)
|
| SetCapping(...)
| SetCapping(self, _arg:int) -> None
| C++: virtual void SetCapping(vtkTypeBool _arg)
|
| Turn on/off whether to cap cylinder with polygons. Initial value
| is true.
|
| SetCapsuleCap(...)
| SetCapsuleCap(self, _arg:int) -> None
| C++: virtual void SetCapsuleCap(vtkTypeBool _arg)
|
| Set/Get whether the capping should make the cylinder a capsule.
| This adds hemispherical caps at the ends of the cylinder.
|
| \sa SetCapping()
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set/Get cylinder center. Initial value is (0.0,0.0,0.0)
|
| SetHeight(...)
| SetHeight(self, _arg:float) -> None
| C++: virtual void SetHeight(double _arg)
|
| Set the height of the cylinder. Initial value is 1.
|
| SetLatLongTessellation(...)
| SetLatLongTessellation(self, _arg:int) -> None
| C++: virtual void SetLatLongTessellation(vtkTypeBool _arg)
|
| Cause the spheres to be tessellated with edges along the latitude
| and longitude lines. If off, triangles are generated at non-polar
| regions, which results in edges that are not parallel to latitude
| and longitude lines. If on, quadrilaterals are generated
| everywhere except at the poles. This can be useful for generating
| wireframe spheres with natural latitude and longitude lines.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetRadius(...)
| SetRadius(self, _arg:float) -> None
| C++: virtual void SetRadius(double _arg)
|
| Set the radius of the cylinder. Initial value is 0.5
|
| SetResolution(...)
| SetResolution(self, _arg:int) -> None
| C++: virtual void SetResolution(int _arg)
|
| Set the number of facets used to define cylinder. Initial value
| is 6.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkCylinderSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkCylinderSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkCylinderSource:
|
| __this__
| Pointer to the C++ object.
|
| lat_long_tessellation
| read-write, calls GetLatLongTessellation/SetLatLongTessellation
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkCylinderSource:
|
| __vtkname__ = 'vtkCylinderSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.CylinderStructured
Python Library Documentation: function CylinderStructured in module pyvista.core.utilities.geometric_objects
CylinderStructured(radius: 'float' = 0.5, height: 'float' = 1.0, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0), theta_resolution: 'int' = 32, z_resolution: 'int' = 10) -> 'StructuredGrid'
Create a cylinder mesh as a :class:`pyvista.StructuredGrid`.
The end caps are left open. This can create a surface mesh if a single
value for the ``radius`` is given or a 3D mesh if multiple radii are given
as a list/array in the ``radius`` argument.
Parameters
----------
radius : float | sequence[float], default: 0.5
Radius of the cylinder. If a sequence, then describes the
radial coordinates of the cells as a range of values as
specified by the ``radius``.
height : float, default: 1.0
Height of the cylinder along its Z-axis.
center : sequence[float], default: (0.0, 0.0, 0.0)
Location of the centroid in ``[x, y, z]``.
direction : sequence[float], default: (1.0, 0.0, 0.0)
Direction cylinder Z-axis in ``[x, y, z]``.
theta_resolution : int, default: 32
Number of points on the circular face of the cylinder.
Ignored if ``radius`` is an iterable.
z_resolution : int, default: 10
Number of points along the height (Z-axis) of the cylinder.
Returns
-------
pyvista.StructuredGrid
Structured cylinder.
Notes
-----
.. versionchanged:: 0.38.0
Prior to version 0.38, this method had incorrect results, producing
inconsistent number of points on the circular face of the cylinder.
Examples
--------
Default structured cylinder
>>> import pyvista as pv
>>> mesh = pv.CylinderStructured()
>>> mesh.plot(show_edges=True)
Structured cylinder with an inner radius of 1, outer of 2, with 5
segments.
>>> import numpy as np
>>> mesh = pv.CylinderStructured(radius=np.linspace(1, 2, 5))
>>> mesh.plot(show_edges=True)
pyvista.DEFAULT_SCALARS_NAME
Error rendering doc: No Python documentation found for 'Data'. Use help() to get the interactive help utility. Use help(str) for help on the str class.
pyvista.DEMReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.DICOMReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.DataObject
Python Library Documentation: class DataObject in module pyvista.core.dataobject
class DataObject(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride)
| DataObject(*args, **kwargs) -> '_T'
|
| Methods common to all wrapped data objects.
|
| Parameters
| ----------
| *args :
| Any extra args are passed as option to all wrapped data objects.
|
| **kwargs :
| Any extra keyword args are passed as option to all wrapped data objects.
|
| Method resolution order:
| DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| builtins.object
|
| Methods defined here:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __init__(self: 'Self', *args, **kwargs) -> 'None'
| Initialize the data object.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_meta_from(self: 'Self', *args, **kwargs) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Intended to be overridden by subclasses.
|
| Parameters
| ----------
| *args : tuple
| Positional arguments.
|
| **kwargs : dict, optional
| Keyword arguments.
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| get_data_range(self: 'Self', name: 'str | None', preference: 'FieldAssociation | str') -> 'tuple[float, float]'
| Get the non-NaN min and max of a named array.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| is_empty
| Return ``True`` if the object is empty.
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'get_data_range', 'is_empty'})
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
pyvista.DataObjectFilters
Python Library Documentation: class DataObjectFilters in module pyvista.core.filters.data_object
class DataObjectFilters(builtins.object)
| DataObjectFilters(*args, **kwargs)
|
| A set of common filters that can be applied to any DataSet or MultiBlock.
|
| Methods defined here:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'points': 'pyvista_ndarray'}
pyvista.DataSet
Python Library Documentation: class DataSet in module pyvista.core.dataset
class DataSet(pyvista.core.filters.data_set.DataSetFilters, pyvista.core.dataobject.DataObject)
| DataSet(*args, **kwargs) -> '_T'
|
| Methods in common to spatially referenced objects.
|
| Parameters
| ----------
| *args :
| Any extra args are passed as option to spatially referenced objects.
|
| **kwargs :
| Any extra keyword args are passed as option to spatially referenced objects.
|
| Method resolution order:
| DataSet
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| builtins.object
|
| Methods defined here:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __init__(self: 'Self', *args, **kwargs) -> 'None'
| Initialize the common object.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| __repr__(self: 'Self') -> 'str'
| Return the object representation.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| __str__(self: 'Self') -> 'str'
| Return the object string representation.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
pyvista.DataSetAccessor
Python Library Documentation: class DataSetAccessor in module pyvista.core.utilities.accessor_registry
class DataSetAccessor(typing.Protocol)
| DataSetAccessor(dataset: 'Any') -> 'None'
|
| Structural protocol for third-party accessor classes.
|
| An accessor class must accept the dataset instance as its single
| ``__init__`` argument. Any public methods on the class become
| available as ``dataset.<namespace>.<method>(...)`` once the class is
| registered with :func:`~pyvista.register_dataset_accessor`.
|
| This Protocol exists primarily for static type analysis: plugin
| authors can annotate ``accessor_cls: type[DataSetAccessor]`` (or
| use it as a return annotation) to have mypy/pyright check that
| their accessor class conforms. The runtime ``isinstance`` check is
| intentionally permissive (every class has ``__init__``), so prefer
| the static-typing use.
|
| .. versionadded:: 0.48.0
|
| Examples
| --------
| Declare an accessor that satisfies the protocol.
|
| >>> from pyvista import DataSetAccessor
| >>> class MyAccessor:
| ... def __init__(self, dataset):
| ... self._dataset = dataset
| >>> isinstance(MyAccessor(None), DataSetAccessor)
| True
|
| Method resolution order:
| DataSetAccessor
| typing.Protocol
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, dataset: 'Any') -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __subclasshook__ = _proto_hook(other) from typing
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| __non_callable_proto_members__ = set()
|
| __parameters__ = ()
|
| __protocol_attrs__ = set()
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Protocol:
|
| __init_subclass__(*args, **kwargs)
| Function to initialize subclasses.
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Generic:
|
| __class_getitem__(...)
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
pyvista.DataSetAttributes
Python Library Documentation: class DataSetAttributes in module pyvista.core.datasetattributes
class DataSetAttributes(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.VTKObjectWrapperCheckSnakeCase)
| DataSetAttributes(*args, **kwargs) -> '_T'
|
| Python friendly wrapper of :vtk:`vtkDataSetAttributes`.
|
| This class provides the ability to pick one of the present arrays as the
| currently active array for each attribute type by implementing a
| ``dict`` like interface.
|
| When adding data arrays but not desiring to set them as active
| scalars or vectors, use :func:`DataSetAttributes.set_array`.
|
| When adding directional data (such as velocity vectors), use
| :func:`DataSetAttributes.set_vectors`.
|
| When adding non-directional data (such as temperature values or
| multi-component scalars like RGBA values), use
| :func:`DataSetAttributes.set_scalars`.
|
| .. versionchanged:: 0.32.0
| The ``[]`` operator no longer allows integers. Use
| :func:`DataSetAttributes.get_array` to retrieve an array
| using an index.
|
| Parameters
| ----------
| vtkobject : :vtk:`vtkFieldData`
| The vtk object to wrap as a :class:~pyvista.DataSetAttribute`,
| usually an instance of :vtk:`vtkCellData`, :vtk:`vtkPointData`, or
| :vtk:`vtkFieldData`.
|
| dataset : :vtk:`vtkDataSet`
| The :vtk:`vtkDataSet` containing the vtkobject.
|
| association : FieldAssociation
| The array association type of the vtkobject.
|
| Notes
| -----
| When printing out the point arrays, you can see which arrays are
| the active scalars, vectors, normals, and texture coordinates.
| In the arrays list, ``SCALARS`` denotes that these are the active
| scalars, ``VECTORS`` denotes that these arrays are tagged as the
| active vectors data (i.e. data with magnitude and direction) and
| so on.
|
| Examples
| --------
| Store data with point association in a DataSet.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.point_data['my_data'] = range(mesh.n_points)
| >>> data = mesh.point_data['my_data']
| >>> data
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Change the data array and show that this is reflected in the DataSet.
|
| >>> data[:] = 0
| >>> mesh.point_data['my_data']
| pyvista_ndarray([0, 0, 0, 0, 0, 0, 0, 0])
|
| Remove the array.
|
| >>> del mesh.point_data['my_data']
| >>> 'my_data' in mesh.point_data
| False
|
| Print the available arrays from dataset attributes.
|
| >>> import numpy as np
| >>> mesh = pv.Plane(i_resolution=1, j_resolution=1)
| >>> mesh.point_data.set_array(range(4), 'my-data')
| >>> mesh.point_data.set_array(range(5, 9), 'my-other-data')
| >>> vectors0 = np.random.default_rng().random((4, 3))
| >>> mesh.point_data.set_vectors(vectors0, 'vectors0')
| >>> vectors1 = np.random.default_rng().random((4, 3))
| >>> mesh.point_data.set_vectors(vectors1, 'vectors1')
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : None
| Active Vectors : vectors1
| Active Texture : TextureCoordinates
| Active Normals : Normals
| Contains arrays :
| Normals float32 (4, 3) NORMALS
| TextureCoordinates float32 (4, 2) TCOORDS
| my-data int64 (4,)
| my-other-data int64 (4,)
| vectors1 float64 (4, 3) VECTORS
| vectors0 float64 (4, 3)
|
| Method resolution order:
| DataSetAttributes
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.VTKObjectWrapperCheckSnakeCase
| vtkmodules.numpy_interface.dataset_adapter.VTKObjectWrapper
| builtins.object
|
| Methods defined here:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export via the Arrow PyCapsule interface.
|
| Implements `the Arrow PyCapsule interface
| <https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html>`_
| so pandas, polars, DuckDB, ibis, narwhals, and other Arrow-aware
| consumers can ingest ``point_data`` / ``cell_data`` directly.
|
| Delegates to :meth:`to_arrow`, so the same memory-sharing rules
| apply: scalar 1D columns are zero-copy, multi-component expanded
| columns are copied.
|
| Requires :mod:`pyarrow`.
|
| __bool__(self: 'Self') -> 'bool'
| Return ``True`` when there are arrays present.
|
| __contains__(self: 'Self', name: 'str') -> 'bool'
| Implement the ``in`` operator.
|
| Uses VTK's native ``HasArray`` for an O(1) lookup, avoiding the
| cost of materialising every array name into a Python list. Falls
| back to ``self.keys()`` for the empty-name lookup so that
| ``keys()``'s legacy auto-rename side-effect (renaming any
| unnamed arrays to ``Unnamed_<i>``) still fires; some plotter
| codepaths (notably ``set_custom_opacity`` for array-valued
| ``opacity=`` arguments) inject anonymous arrays and rely on that
| side-effect to give them a unique, lookup-able name before
| downstream code activates them.
|
| __delitem__(self: 'Self', key: 'str') -> 'None'
| Implement del with array name or index.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test dict-like equivalency.
|
| __getitem__(self: 'Self', key: 'str') -> 'pyvista_ndarray'
| Implement ``[]`` operator.
|
| Accepts an array name.
|
| __init__(self: 'Self', vtkobject: '_vtk.vtkFieldData', dataset: '_vtk.vtkDataSet | DataSet', association: 'FieldAssociation') -> 'None'
| Initialize DataSetAttributes.
|
| __iter__(self: 'Self') -> 'Iterator[str]'
| Implement for loop iteration.
|
| __len__(self: 'Self') -> 'int'
| Return the number of arrays.
|
| __repr__(self: 'Self') -> 'str'
| Printable representation of DataSetAttributes.
|
| __setitem__(self: 'Self', key: 'str', value: 'ArrayLike[Any]') -> 'None'
| Implement setting with the ``[]`` operator.
|
| clear(self: 'Self') -> 'None'
| Remove all arrays in this object.
|
| Examples
| --------
| Add an array to ``point_data`` to a DataSet and then clear the
| point_data.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_data'] = range(mesh.n_points)
| >>> len(mesh.point_data)
| 1
| >>> mesh.point_data.clear()
| >>> len(mesh.point_data)
| 0
|
| get(self: 'Self', key: 'str', value: 'Any | None' = None) -> 'pyvista_ndarray | None'
| Return the value of the item with the specified key.
|
| Parameters
| ----------
| key : str
| Name of the array item you want to return the value from.
|
| value : Any, optional
| A value to return if the key does not exist. Default
| is ``None``.
|
| Returns
| -------
| Any
| Array if the ``key`` exists in the dataset, otherwise
| ``value``.
|
| Examples
| --------
| Show that the default return value for a non-existent key is
| ``None``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.point_data['my_data'] = range(mesh.n_points)
| >>> mesh.point_data.get('my-other-data')
|
| get_array(self: 'Self', key: 'str | int') -> 'pyvista_ndarray'
| Get an array in this object.
|
| Parameters
| ----------
| key : str | int
| The name or index of the array to return. Arrays are
| ordered within VTK DataSetAttributes, and this feature is
| mirrored here.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Returns a :class:`pyvista.pyvista_ndarray`.
|
| Raises
| ------
| KeyError
| If the key does not exist.
|
| Notes
| -----
| This is provided since arrays are ordered within VTK and can
| be indexed via an int. When getting an array, you can just
| use the key of the array with the ``[]`` operator with the
| name of the array.
|
| Examples
| --------
| Store data with point association in a DataSet.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_data'] = range(mesh.n_points)
|
| Access using an index.
|
| >>> mesh.point_data.get_array(0)
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Access using a key.
|
| >>> mesh.point_data.get_array('my_data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| items(self: 'Self') -> 'list[tuple[str, pyvista_ndarray]]'
| Return a list of (array name, array value) tuples.
|
| Returns
| -------
| list
| List of keys and values.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['data0'] = [0] * mesh.n_cells
| >>> mesh.cell_data['data1'] = range(mesh.n_cells)
| >>> mesh.cell_data.items() # doctest: +NORMALIZE_WHITESPACE
| [('data0', pyvista_ndarray([0, 0, 0, 0, 0, 0])),
| ('data1', pyvista_ndarray([0, 1, 2, 3, 4, 5]))]
|
| keys(self: 'Self') -> 'list[str]'
| Return the names of the arrays as a list.
|
| Returns
| -------
| list
| List of keys.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.clear_data()
| >>> mesh.point_data['data0'] = [0] * mesh.n_points
| >>> mesh.point_data['data1'] = range(mesh.n_points)
| >>> mesh.point_data.keys()
| ['data0', 'data1']
|
| pop(self: 'Self', key: 'str', default: 'pyvista_ndarray | T' = pyvista_ndarray([], dtype=float64)) -> 'pyvista_ndarray | T'
| Remove an array and return it.
|
| Parameters
| ----------
| key : str
| The name of the array to remove and return.
|
| default : Any, optional
| If default is not given and key is not in the dictionary,
| a KeyError is raised.
|
| Returns
| -------
| pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Add a point data array to a DataSet and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.point_data['my_data'] = range(mesh.n_points)
| >>> mesh.point_data.pop('my_data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Show that the array no longer exists in ``point_data``.
|
| >>> 'my_data' in mesh.point_data
| False
|
| remove(self: 'Self', key: 'str') -> 'None'
| Remove an array.
|
| Parameters
| ----------
| key : str
| The name of the array to remove.
|
| Notes
| -----
| You can also use the ``del`` statement.
|
| Examples
| --------
| Add a point data array to a DataSet and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.point_data['my_data'] = range(mesh.n_points)
| >>> mesh.point_data.remove('my_data')
|
| Show that the array no longer exists in ``point_data``.
|
| >>> 'my_data' in mesh.point_data
| False
|
| set_array(self: 'Self', data: 'ArrayLike[float]', name: 'str', deep_copy: 'bool' = False) -> 'None'
| Add an array to this object.
|
| Use this method when adding arrays to the DataSet. If
| needed, these arrays can later be assigned to become the
| active scalars, vectors, normals, or texture coordinates with:
|
| * :attr:`active_scalars_name`
| * :attr:`active_vectors_name`
| * :attr:`active_normals_name`
| * :attr:`active_texture_coordinates_name`
|
| Parameters
| ----------
| data : ArrayLike[float]
| Array of data.
|
| name : str
| Name to assign to the data. If this name already exists,
| it will be overwritten.
|
| deep_copy : bool, optional
| When ``True`` makes a full copy of the array.
|
| Notes
| -----
| You can simply use the ``[]`` operator to add an array to the
| dataset. Note that this will automatically become the active
| scalars.
|
| Examples
| --------
| Add a point array to a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> data = range(mesh.n_points)
| >>> mesh.point_data.set_array(data, 'my-data')
| >>> mesh.point_data['my-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Add a cell array to a mesh.
|
| >>> cell_data = range(mesh.n_cells)
| >>> mesh.cell_data.set_array(cell_data, 'my-data')
| >>> mesh.cell_data['my-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Add field data to a mesh.
|
| >>> field_data = range(3)
| >>> mesh.field_data.set_array(field_data, 'my-data')
| >>> mesh.field_data['my-data']
| pyvista_ndarray([0, 1, 2])
|
| set_scalars(self: 'Self', scalars: 'ArrayLike[float]', name: 'str' = 'scalars', deep_copy: 'bool' = False) -> 'None'
| Set the active scalars of the dataset with an array.
|
| In VTK and PyVista, scalars are a quantity that has no
| direction. This can include data with multiple components
| (such as RGBA values) or just one component (such as
| temperature data).
|
| See :func:`DataSetAttributes.set_vectors` when adding arrays
| that contain magnitude and direction.
|
| Parameters
| ----------
| scalars : ArrayLike[float]
| Array of data.
|
| name : str, default: 'scalars'
| Name to assign the scalars.
|
| deep_copy : bool, default: False
| When ``True`` makes a full copy of the array.
|
| Notes
| -----
| When adding directional data (such as velocity vectors), use
| :func:`DataSetAttributes.set_vectors`.
|
| Complex arrays will be represented internally as a 2 component float64
| array. This is due to limitations of VTK's native datatypes.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> scalars = range(mesh.n_points)
| >>> mesh.point_data.set_scalars(scalars, 'my-scalars')
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my-scalars
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my-scalars int64 (8,) SCALARS
|
| set_vectors(self: 'Self', vectors: 'MatrixLike[float]', name: 'str', deep_copy: 'bool' = False) -> 'None'
| Set the active vectors of this data attribute.
|
| Vectors are a quantity that has magnitude and direction, such
| as normal vectors or a velocity field.
|
| The vectors data must contain three components per cell or point. Use
| :func:`DataSetAttributes.set_scalars` when adding non-directional data.
|
| Parameters
| ----------
| vectors : MatrixLike
| Data shaped ``(n, 3)`` where n matches the number of points or cells.
|
| name : str
| Name of the vectors.
|
| deep_copy : bool, default: False
| When ``True`` makes a full copy of the array. When ``False``, the
| data references the original array without copying it.
|
| Notes
| -----
| PyVista and VTK treats vectors and scalars differently when performing
| operations. Vector data, unlike scalar data, is rotated along with the
| geometry when the DataSet is passed through a transformation filter.
|
| When adding non-directional data (such temperature values or
| multi-component scalars like RGBA values), you can also use
| :func:`DataSetAttributes.set_scalars`.
|
| Examples
| --------
| Add random vectors to a mesh as point data.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> vectors = np.random.default_rng().random((mesh.n_points, 3))
| >>> mesh.point_data.set_vectors(vectors, 'my-vectors')
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : None
| Active Vectors : my-vectors
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my-vectors float64 (8, 3) VECTORS
|
| to_arrow(self: 'Self') -> 'pyarrow.Table'
| Return this attribute set as a :class:`pyarrow.Table`.
|
| Each array becomes a column. Multi-component arrays (e.g. a
| ``(N, 3)`` vector field) are expanded to one column per component,
| named ``{array_name}_{i}``. Only ``point_data`` and ``cell_data``
| can be converted. ``field_data`` raises :class:`ValueError`
| because its arrays may have differing lengths.
|
| Requires :mod:`pyarrow`.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array and
| :attr:`valid_array_len` rows.
|
| Notes
| -----
| Memory sharing with the underlying VTK buffers is mixed:
|
| - 1D contiguous numeric columns (scalar arrays) wrap the VTK
| buffer zero-copy. The Arrow column and the VTK array point at
| the same memory.
| - Expanded multi-component columns (``{name}_{i}``) come from
| strided slices and are copied into contiguous buffers.
| - Booleans, complex numbers, and strings go through pyvista's
| existing VTK conversion and are copied.
|
| Arrow buffers are immutable by contract, so consumers cannot
| mutate VTK memory through the returned table.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> table = mesh.point_data.to_arrow()
| >>> table.num_rows
| 8
|
| to_pandas(self: 'Self') -> 'pandas.DataFrame'
| Return this attribute set as a :class:`pandas.DataFrame`.
|
| Each array becomes a column. Multi-component arrays are expanded
| to one column per component, named ``{array_name}_{i}``. Only
| ``point_data`` and ``cell_data`` can be converted.
| ``field_data`` raises :class:`ValueError`.
|
| Requires :mod:`pandas`.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array and
| :attr:`valid_array_len` rows.
|
| Notes
| -----
| Pandas consolidates the dict of columns into internal blocks
| during construction, which copies the data. The returned
| DataFrame is effectively a snapshot and does not share memory
| with VTK. Callers that need zero-copy access should use
| :meth:`to_arrow` instead.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.point_data.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| update(self: 'Self', array_dict: 'dict[str, NumpyArray[float]] | DataSetAttributes', copy: 'bool' = True) -> 'None'
| Update arrays in this object from another dictionary or dataset attributes.
|
| For each key, value given, add the pair. If it already exists, replace
| it with the new array. These arrays will be copied.
|
| Parameters
| ----------
| array_dict : dict, DataSetAttributes
| A dictionary of ``(array name, :class:`numpy.ndarray`)`` or a
| :class:`pyvista.DataSetAttributes`.
|
| copy : bool, default: True
| If ``True``, arrays from ``array_dict`` are copied to this object.
|
| Examples
| --------
| Add two arrays to ``point_data`` using ``update``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> n = len(mesh.point_data)
| >>> arrays = {
| ... 'foo': np.arange(mesh.n_points),
| ... 'rand': np.random.default_rng().random(mesh.n_points),
| ... }
| >>> mesh.point_data.update(arrays)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| foo int64 (1000,)
| rand float64 (1000,)
|
| values(self: 'Self') -> 'list[pyvista_ndarray]'
| Return the arrays as a list.
|
| Returns
| -------
| list
| List of arrays.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['data0'] = [0] * mesh.n_cells
| >>> mesh.cell_data['data1'] = range(mesh.n_cells)
| >>> mesh.cell_data.values()
| [pyvista_ndarray([0, 0, 0, 0, 0, 0]), pyvista_ndarray([0, 1, 2, 3, 4, 5])]
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| active_scalars
| Return the active scalars.
|
| .. versionchanged:: 0.32.0
| Can no longer be used to set the active scalars. Either use
| :func:`DataSetAttributes.set_scalars` or if the array
| already exists, assign to
| :attr:`pyvista.DataSetAttributes.active_scalars_name`.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars.
|
| Examples
| --------
| Associate point data to a simple cube mesh and show that the
| active scalars in the point array are the most recently added
| array.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.point_data['data0'] = np.arange(mesh.n_points)
| >>> mesh.point_data.active_scalars
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| active_vectors
| Return the active vectors as a pyvista_ndarray.
|
| .. versionchanged:: 0.32.0
| Can no longer be used to set the active vectors. Either use
| :func:`DataSetAttributes.set_vectors` or if the array
| already exists, assign to
| :attr:`pyvista.DataSetAttributes.active_vectors_name`.
|
| Returns
| -------
| Optional[np.ndarray]
| Active vectors as a pyvista_ndarray.
|
| Examples
| --------
| Associate point data to a simple cube mesh and show that the
| active vectors in the point array are the most recently added
| array.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> vectors = np.random.default_rng().random((mesh.n_points, 3))
| >>> mesh.point_data.set_vectors(vectors, 'my-vectors')
| >>> vectors_out = mesh.point_data.active_vectors
| >>> vectors_out.shape
| (8, 3)
|
| valid_array_len
| Return the length data should be when added to the dataset.
|
| If there are no restrictions, returns ``None``.
|
| Returns
| -------
| Optional[int]
| Length data should be when added to the dataset.
|
| Examples
| --------
| Show that valid array lengths match the number of points and
| cells for point and cell arrays, and there is no length limit
| for field data.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.n_points, mesh.n_cells
| (8, 6)
| >>> mesh.point_data.valid_array_len
| 8
| >>> mesh.cell_data.valid_array_len
| 6
| >>> mesh.field_data.valid_array_len is None
| True
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| active_normals
| Return the normals.
|
| Returns
| -------
| pyvista_ndarray
| Normals of this dataset attribute. ``None`` if no normals have been
| set.
|
| Notes
| -----
| Field data will have no normals.
|
| Examples
| --------
| First, compute cell normals.
|
| >>> import pyvista as pv
| >>> mesh = pv.Plane(i_resolution=1, j_resolution=1)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : None
| Active Vectors : None
| Active Texture : TextureCoordinates
| Active Normals : Normals
| Contains arrays :
| Normals float32 (4, 3) NORMALS
| TextureCoordinates float32 (4, 2) TCOORDS
|
| >>> mesh.point_data.active_normals
| pyvista_ndarray([[0., 0., 1.],
| [0., 0., 1.],
| [0., 0., 1.],
| [0., 0., 1.]], dtype=float32)
|
| Assign normals to the cell arrays. An array will be added
| named ``"Normals"``.
|
| >>> mesh.cell_data.active_normals = [[0.0, 0.0, 1.0]]
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : Normals
| Contains arrays :
| Normals float64 (1, 3) NORMALS
|
| active_normals_name
| Return the name of the normals array.
|
| Returns
| -------
| str
| Name of the active normals array.
|
| Examples
| --------
| First, compute cell normals.
|
| >>> import pyvista as pv
| >>> mesh = pv.Plane(i_resolution=1, j_resolution=1)
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.point_data.active_normals_name
| 'Normals'
|
| active_scalars_name
| Return name of the active scalars.
|
| Returns
| -------
| Optional[str]
| Name of the active scalars.
|
| Examples
| --------
| Add two arrays to the mesh point data. Note how the first array becomes
| the active scalars since the ``mesh`` contained no scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_data'] = range(mesh.n_points)
| >>> mesh.point_data['my_other_data'] = range(mesh.n_points)
| >>> mesh.point_data.active_scalars_name
| 'my_data'
|
| Set the name of the active scalars.
|
| >>> mesh.point_data.active_scalars_name = 'my_other_data'
| >>> mesh.point_data.active_scalars_name
| 'my_other_data'
|
| active_texture_coordinates
| Return the active texture coordinates array.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Array of the active texture coordinates.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.point_data.active_texture_coordinates
| pyvista_ndarray([[-0., 0.],
| [ 0., 0.],
| [ 0., 1.],
| [-0., 1.],
| [-1., 0.],
| [-1., 1.],
| [ 1., 1.],
| [ 1., 0.]], dtype=float32)
|
| active_texture_coordinates_name
| Return the name of the active texture coordinates array.
|
| Returns
| -------
| Optional[str]
| Name of the active texture coordinates array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.point_data.active_texture_coordinates_name
| 'TCoords'
|
| active_vectors_name
| Return name of the active vectors.
|
| Returns
| -------
| Optional[str]
| Name of the active vectors.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.set_vectors(
| ... np.random.default_rng().random((mesh.n_points, 3)),
| ... 'my-vectors',
| ... )
| >>> mesh.point_data.active_vectors_name
| 'my-vectors'
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.VTKObjectWrapperCheckSnakeCase:
|
| __getattr__(self, name: 'str')
| Forward unknown attribute requests to VTKArray's __getattr__.
pyvista.DataSetFilters
Python Library Documentation: class DataSetFilters in module pyvista.core.filters.data_set
class DataSetFilters(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.filters.data_object.DataObjectFilters)
| DataSetFilters(*args, **kwargs)
|
| A set of common filters that can be applied to any :vtk:`vtkDataSet`.
|
| Method resolution order:
| DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| builtins.object
|
| Methods defined here:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
pyvista.DataSetWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.DeprecationError
Python Library Documentation: class DeprecationError in module pyvista.core.errors class DeprecationError(builtins.RuntimeError) | DeprecationError(message='This feature has been deprecated') -> 'None' | | Used for deprecated methods and functions. | | Parameters | ---------- | message : str | Error message. | | Method resolution order: | DeprecationError | builtins.RuntimeError | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, message='This feature has been deprecated') -> 'None' | Empty init. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Static methods inherited from builtins.RuntimeError: | | __new__(*args, **kwargs) class method of builtins.RuntimeError | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.Disc
Python Library Documentation: function Disc in module pyvista.core.utilities.geometric_objects
Disc(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), inner: 'float' = 0.25, outer: 'float' = 0.5, normal: 'VectorLike[float]' = (0.0, 0.0, 1.0), r_res: 'int' = 1, c_res: 'int' = 6) -> 'PolyData'
Create a polygonal disk with a hole in the center.
The disk has zero height. The user can specify the inner and outer
radius of the disk, and the radial and circumferential resolution
of the polygonal representation.
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Center in ``[x, y, z]``. Middle of the axis of the disc.
inner : float, default: 0.25
The inner radius.
outer : float, default: 0.5
The outer radius.
normal : sequence[float], default: (0.0, 0.0, 1.0)
Direction vector in ``[x, y, z]``. Orientation vector of the disc.
r_res : int, default: 1
Number of points in radial direction.
c_res : int, default: 6
Number of points in circumferential direction.
Returns
-------
pyvista.PolyData
Disk mesh.
Examples
--------
Create a disc with 50 points in the circumferential direction.
>>> import pyvista as pv
>>> mesh = pv.Disc(c_res=50)
>>> mesh.plot(show_edges=True, line_width=5)
pyvista.DiscSource
Python Library Documentation: class DiscSource in module pyvista.core.utilities.geometric_sources
class DiscSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkDiskSource)
| DiscSource(*args, **kwargs) -> '_T'
|
| Disc source algorithm class.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Center in ``[x, y, z]``. Middle of the axis of the disc.
|
| inner : float, default: 0.25
| The inner radius.
|
| outer : float, default: 0.5
| The outer radius.
|
| r_res : int, default: 1
| Number of points in radial direction.
|
| c_res : int, default: 6
| Number of points in circumferential direction.
|
| Examples
| --------
| Create a disc with 50 points in the circumferential direction.
|
| >>> import pyvista as pv
| >>> source = pv.DiscSource(c_res=50)
| >>> source.output.plot(show_edges=True, line_width=5)
|
| Method resolution order:
| DiscSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkDiskSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'DiscSource', center: 'VectorLike[float] | None' = None, inner: 'float' = 0.25, outer: 'float' = 0.5, r_res: 'int' = 1, c_res: 'int' = 6) -> 'None'
| Initialize the disc source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Line mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| c_res
| Get number of points in circumferential direction.
|
| Returns
| -------
| int
| Number of points in circumferential direction.
|
| center
| Get the center in ``[x, y, z]``.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``.
|
| inner
| Get the inner radius.
|
| Returns
| -------
| float
| The inner radius.
|
| outer
| Get the outer radius.
|
| Returns
| -------
| float
| The outer radius.
|
| r_res
| Get number of points in radial direction.
|
| Returns
| -------
| int
| Number of points in radial direction.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkDiskSource:
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetCircumferentialResolution(...)
| GetCircumferentialResolution(self) -> int
| C++: virtual int GetCircumferentialResolution()
|
| GetCircumferentialResolutionMaxValue(...)
| GetCircumferentialResolutionMaxValue(self) -> int
| C++: virtual int GetCircumferentialResolutionMaxValue()
|
| GetCircumferentialResolutionMinValue(...)
| GetCircumferentialResolutionMinValue(self) -> int
| C++: virtual int GetCircumferentialResolutionMinValue()
|
| GetInnerRadius(...)
| GetInnerRadius(self) -> float
| C++: virtual double GetInnerRadius()
|
| GetInnerRadiusMaxValue(...)
| GetInnerRadiusMaxValue(self) -> float
| C++: virtual double GetInnerRadiusMaxValue()
|
| GetInnerRadiusMinValue(...)
| GetInnerRadiusMinValue(self) -> float
| C++: virtual double GetInnerRadiusMinValue()
|
| GetNormal(...)
| GetNormal(self) -> (float, float, float)
| C++: virtual double *GetNormal()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOuterRadius(...)
| GetOuterRadius(self) -> float
| C++: virtual double GetOuterRadius()
|
| GetOuterRadiusMaxValue(...)
| GetOuterRadiusMaxValue(self) -> float
| C++: virtual double GetOuterRadiusMaxValue()
|
| GetOuterRadiusMinValue(...)
| GetOuterRadiusMinValue(self) -> float
| C++: virtual double GetOuterRadiusMinValue()
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetRadialResolution(...)
| GetRadialResolution(self) -> int
| C++: virtual int GetRadialResolution()
|
| GetRadialResolutionMaxValue(...)
| GetRadialResolutionMaxValue(self) -> int
| C++: virtual int GetRadialResolutionMaxValue()
|
| GetRadialResolutionMinValue(...)
| GetRadialResolutionMinValue(self) -> int
| C++: virtual int GetRadialResolutionMinValue()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkDiskSource
| C++: vtkDiskSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkDiskSource
| C++: static vtkDiskSource *SafeDownCast(vtkObjectBase *o)
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set the center of the disk. The default is (0, 0, 0).
|
| SetCircumferentialResolution(...)
| SetCircumferentialResolution(self, _arg:int) -> None
| C++: virtual void SetCircumferentialResolution(int _arg)
|
| Set the number of points in circumferential direction.
|
| SetInnerRadius(...)
| SetInnerRadius(self, _arg:float) -> None
| C++: virtual void SetInnerRadius(double _arg)
|
| Specify inner radius of hole in disk.
|
| SetNormal(...)
| SetNormal(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetNormal(double _arg1, double _arg2,
| double _arg3)
| SetNormal(self, _arg:(float, float, float)) -> None
| C++: virtual void SetNormal(const double _arg[3])
|
| Set/get plane normal. The default is (0, 0, 1).
|
| SetOuterRadius(...)
| SetOuterRadius(self, _arg:float) -> None
| C++: virtual void SetOuterRadius(double _arg)
|
| Specify outer radius of disk.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetRadialResolution(...)
| SetRadialResolution(self, _arg:int) -> None
| C++: virtual void SetRadialResolution(int _arg)
|
| Set the number of points in radius direction.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkDiskSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkDiskSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkDiskSource:
|
| __this__
| Pointer to the C++ object.
|
| circumferential_resolution
| read-write, calls GetCircumferentialResolution/SetCircumferentialResolution
|
| inner_radius
| read-write, calls GetInnerRadius/SetInnerRadius
|
| normal
| read-write, calls GetNormal/SetNormal
|
| outer_radius
| read-write, calls GetOuterRadius/SetOuterRadius
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| radial_resolution
| read-write, calls GetRadialResolution/SetRadialResolution
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkDiskSource:
|
| __vtkname__ = 'vtkDiskSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.Dodecahedron
Python Library Documentation: function Dodecahedron in module pyvista.core.utilities.geometric_objects
Dodecahedron(radius: 'float' = 1.0, center: 'VectorLike[float]' = (0.0, 0.0, 0.0)) -> 'PolyData'
Create a dodecahedron of a given size.
A dodecahedron is composed of twelve congruent regular pentagons.
Parameters
----------
radius : float, default: 1.0
The radius of the circumscribed sphere for the dodecahedron.
center : sequence[float], default: (0.0, 0.0, 0.0)
Three-length sequence defining the center of the dodecahedron.
Returns
-------
pyvista.PolyData
Mesh for the dodecahedron. Cell scalars are defined that assign
integer labels to each face (with array name ``"FaceIndex"``).
Examples
--------
Create and plot a dodecahedron.
>>> import pyvista as pv
>>> tetra = pv.Dodecahedron()
>>> tetra.plot(categories=True)
See :ref:`create_platonic_solids_example` for more examples using this filter.
pyvista.Ellipse
Python Library Documentation: function Ellipse in module pyvista.core.utilities.geometric_objects
Ellipse(semi_major_axis: 'float' = 0.5, semi_minor_axis: 'float' = 0.2, resolution: 'int' = 100) -> 'PolyData'
Create a single ellipse defined by the Semi-major and Semi-minor axes in the XY plane.
Parameters
----------
semi_major_axis : float, default: 0.5
Semi-major axis of ellipse.
semi_minor_axis : float, default: 0.2
Semi-minor axis of ellipse.
resolution : int, default: 100
Number of points on the ellipse.
Returns
-------
pyvista.PolyData
Ellipse mesh.
Notes
-----
.. versionchanged:: 0.38.0
Prior to version 0.38, this method had incorrect results, producing
inconsistent edge lengths and a duplicated point which is now fixed.
Examples
--------
>>> import pyvista as pv
>>> ellipse = pv.Ellipse(semi_major_axis=8, semi_minor_axis=4)
>>> ellipse.plot(show_edges=True, line_width=5)
pyvista.EnSightReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.ExodusIIBlockSet
Python Library Documentation: class ExodusIIBlockSet in module pyvista.core.utilities.reader
class ExodusIIBlockSet(pyvista.core.utilities.misc._NoNewAttrMixin)
| ExodusIIBlockSet(*args, **kwargs) -> '_T'
|
| Class for enabling and disabling blocks, sets, and block/set arrays in Exodus II files.
|
| Method resolution order:
| ExodusIIBlockSet
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| __init__(self, exodus_reader: 'ExodusIIReader', object_type)
| Initialize self. See help(type(self)) for accurate signature.
|
| array_status(self, name)
| Get the status of the block/set array with name.
|
| Parameters
| ----------
| name: str
| name of set/block array to be disabled.
|
| Returns
| -------
| bool
| Whether the block/set array is enabled.
|
| disable(self, name)
| Disable the block/set with name.
|
| Parameters
| ----------
| name: str
| name of set/block to be disabled.
|
| disable_all(self)
| Disable all names in block/set.
|
| disable_all_arrays(self)
| Disable all arrays in block/set.
|
| disable_array(self, name)
| Disable the block/set array with name.
|
| Parameters
| ----------
| name: str
| name of set/block array to be disabled.
|
| enable(self, name)
| Enable the block/set with name.
|
| Parameters
| ----------
| name: str
| name of set/block to be enabled.
|
| enable_all(self)
| Enable all names in block/set.
|
| enable_all_arrays(self)
| Enable all arrays in block/set.
|
| enable_array(self, name)
| Enable the block/set array with name.
|
| Parameters
| ----------
| name: str
| name of set/block array to be enabled.
|
| status(self, name)
| Get the status of the block/set with name.
|
| Parameters
| ----------
| name: str
| name of set/block to be disabled.
|
| Returns
| -------
| bool
| Whether the block/set is enabled.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| array_names
| Returns the list of the names of the block/set arrays in object.
|
| Returns
| -------
| list[str]
| List of all names of block/set arrays in object.
|
| names
| Returns the list of the names of the sets or blocks in object.
|
| Returns
| -------
| list[str]
| List of all names of blocks/sets in object.
|
| number
| Return the number of blocks or sets in object.
|
| Returns
| -------
| int
| Number of block or sets in object.
|
| number_arrays
| Return the number of block/set arrays in object.
|
| Returns
| -------
| int
| Number of block/set arrays in object.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
pyvista.ExodusIIReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.ExplicitStructuredGrid
Python Library Documentation: class ExplicitStructuredGrid in module pyvista.core.pointset
class ExplicitStructuredGrid(PointGrid, vtkmodules.vtkCommonDataModel.vtkExplicitStructuredGrid)
| ExplicitStructuredGrid(*args, **kwargs) -> '_T'
|
| Extend the functionality of the :vtk:`vtkExplicitStructuredGrid` class.
|
| Can be initialized by the following:
|
| - Creating an empty grid
| - From a :vtk:`vtkStructuredGrid`, :vtk:`vtkExplicitStructuredGrid` or
| :vtk:`vtkUnstructuredGrid` object
| - From a VTU or VTK file
| - From ``dims`` and ``corners`` arrays
| - From ``dims``, ``cells`` and ``points`` arrays
|
| Parameters
| ----------
| args : :vtk:`vtkExplicitStructuredGrid`, :vtk:`vtkUnstructuredGrid`, str, Sequence
| See examples below.
|
| deep : bool, default: False
| Whether to deep copy a :vtk:`vtkUnstructuredGrid` object.
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| :ref:`create_explicit_structured_grid_example`
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>>
| >>> # grid size: ni*nj*nk cells; si, sj, sk steps
| >>> ni, nj, nk = 4, 5, 6
| >>> si, sj, sk = 20, 10, 1
| >>>
| >>> # create raw coordinate grid
| >>> grid_ijk = np.mgrid[
| ... : (ni + 1) * si : si,
| ... : (nj + 1) * sj : sj,
| ... : (nk + 1) * sk : sk,
| ... ]
| >>>
| >>> # repeat array along each Cartesian axis for connectivity
| >>> for axis in range(1, 4):
| ... grid_ijk = grid_ijk.repeat(2, axis=axis)
| >>>
| >>> # slice off unnecessarily doubled edge coordinates
| >>> grid_ijk = grid_ijk[:, 1:-1, 1:-1, 1:-1]
| >>>
| >>> # reorder and reshape to VTK order
| >>> corners = grid_ijk.transpose().reshape(-1, 3)
| >>>
| >>> dims = np.array([ni, nj, nk]) + 1
| >>> grid = pv.ExplicitStructuredGrid(dims, corners)
| >>> grid = grid.compute_connectivity()
| >>> grid.plot(show_edges=True)
|
| Method resolution order:
| ExplicitStructuredGrid
| PointGrid
| _PointSet
| pyvista.core.dataset.DataSet
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkExplicitStructuredGrid
| vtkmodules.vtkCommonDataModel.vtkPointSet
| vtkmodules.vtkCommonDataModel.vtkDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, *args, deep: 'bool' = False, validate: 'bool | _NestedMeshValidationFields' = False)
| Initialize the explicit structured grid.
|
| __repr__(self) -> 'str'
| Return the standard representation.
|
| __str__(self) -> 'str'
| Return the standard ``str`` representation.
|
| cast_to_unstructured_grid(self) -> 'UnstructuredGrid'
| Cast to an unstructured grid.
|
| Returns
| -------
| UnstructuredGrid
| An unstructured grid. VTK adds the ``'BLOCK_I'``,
| ``'BLOCK_J'`` and ``'BLOCK_K'`` cell arrays. These arrays
| are required to restore the explicit structured grid.
|
| See Also
| --------
| pyvista.DataSetFilters.extract_cells : Extract a subset of a dataset.
| pyvista.UnstructuredGrid.cast_to_explicit_structured_grid
| Cast an unstructured grid to an explicit structured grid.
|
| Notes
| -----
| The ghost cell array is disabled before casting the
| unstructured grid in order to allow the original structure
| and attributes data of the explicit structured grid to be
| restored. If you don't need to restore the explicit
| structured grid later or want to extract an unstructured
| grid from the visible subgrid, use the ``extract_cells``
| filter and the cell indices where the ghost cell array is
| ``0``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| >>> grid = grid.hide_cells(range(80, 120))
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| >>> grid = grid.cast_to_unstructured_grid()
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| >>> grid = grid.cast_to_explicit_structured_grid()
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| cell_coords(self, ind: 'int | VectorLike[int]') -> 'None | MatrixLike[int]'
| Return the cell structured coordinates.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell IDs.
|
| Returns
| -------
| output : numpy.ndarray | None
| Cell structured coordinates. ``None`` if ``ind`` is
| outside the grid extent.
|
| See Also
| --------
| pyvista.ExplicitStructuredGrid.cell_id : Return the cell ID.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid.cell_coords(19)
| array([3, 4, 0])
|
| >>> grid.cell_coords((19, 31, 41, 54))
| array([[3, 4, 0],
| [3, 2, 1],
| [1, 0, 2],
| [2, 3, 2]])
|
| cell_id(self, coords: 'ArrayLike[int]') -> 'int | NumpyArray[int] | None'
| Return the cell ID.
|
| Parameters
| ----------
| coords : ArrayLike[int]
| Cell structured coordinates.
|
| Returns
| -------
| output : int | numpy.ndarray | None
| Cell IDs. ``None`` if ``coords`` is outside the grid extent.
|
| See Also
| --------
| pyvista.ExplicitStructuredGrid.cell_coords : Return the cell structured coordinates.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid.cell_id((3, 4, 0))
| np.int64(19)
|
| >>> coords = [(3, 4, 0), (3, 2, 1), (1, 0, 2), (2, 3, 2)]
| >>> grid.cell_id(coords)
| array([19, 31, 41, 54])
|
| clean(self, tolerance=0, remove_unused_points: 'bool' = True, produce_merge_map: 'bool' = True, average_point_data: 'bool' = True, merging_array_name=None, progress_bar: 'bool' = False) -> 'ExplicitStructuredGrid'
| Merge duplicate points and remove unused points in an ExplicitStructuredGrid.
|
| This filter, merging coincident points as defined by a merging
| tolerance and optionally removes unused points. The filter does not
| modify the topology of the input dataset, nor change the types of
| cells. It may however, renumber the cell connectivity ids.
|
| This filter casts the grid to an UnstructuredGrid to clean it, then
| casts the cleaned unstructured grid to an explicit structured grid.
|
| Parameters
| ----------
| tolerance : float, default: 0.0
| The absolute point merging tolerance.
|
| remove_unused_points : bool, default: True
| Indicate whether points unused by any cell are removed from the
| output. Note that when this is off, the filter can successfully
| process datasets with no cells (and just points). If on in this
| case, and there are no cells, the output will be empty.
|
| produce_merge_map : bool, default: False
| Indicate whether a merge map should be produced on output.
| The merge map, if requested, maps each input point to its
| output point id, or provides a value of -1 if the input point
| is not used in the output. The merge map is associated with
| the filter's output field data and is named ``"PointMergeMap"``.
|
| average_point_data : bool, default: True
| Indicate whether point coordinates and point data of merged points
| are averaged. When ``True``, the data coordinates and attribute
| values of all merged points are averaged. When ``False``, the point
| coordinate and data of the single remaining merged point is
| retained.
|
| merging_array_name : str, optional
| If a ``merging_array_name`` is specified and exists in the
| ``point_data``, then point merging will switch into a mode where
| merged points must be both geometrically coincident and have
| matching point data. When set, ``tolerance`` has no effect.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ExplicitStructuredGrid
| Cleaned explicit structured grid.
|
| compute_connections(self, inplace: 'bool' = False) -> 'Self'
| Compute an array with the number of connected cell faces.
|
| This method calculates the number of topological cell
| neighbors connected by faces. The results are stored in the
| ``'number_of_connections'`` cell array.
|
| Parameters
| ----------
| inplace : bool, default: False
| This method is applied to this grid if ``True`` or to a copy
| otherwise.
|
| Returns
| -------
| ExplicitStructuredGrid
| A deep copy of this grid if ``inplace=False`` or this
| DataSet if otherwise.
|
| See Also
| --------
| ExplicitStructuredGrid.compute_connectivity : Compute the faces connectivity flags array.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid = grid.compute_connections()
| >>> grid.plot(show_edges=True)
|
| compute_connectivity(self, inplace: 'bool' = False) -> 'Self'
| Compute the faces connectivity flags array.
|
| This method checks the faces connectivity of the cells with
| their topological neighbors. The result is stored in the
| array of integers ``'ConnectivityFlags'``. Each value in this
| array must be interpreted as a binary number, where the digits
| shows the faces connectivity of a cell with its topological
| neighbors -Z, +Z, -Y, +Y, -X and +X respectively. For example,
| a cell with ``'ConnectivityFlags'`` equal to ``27``
| (``011011``) indicates that this cell is connected by faces
| with their neighbors ``(0, 0, 1)``, ``(0, -1, 0)``,
| ``(-1, 0, 0)`` and ``(1, 0, 0)``.
|
| Parameters
| ----------
| inplace : bool, default: False
| This method is applied to this grid if ``True``
| or to a copy otherwise.
|
| Returns
| -------
| ExplicitStructuredGrid
| A deep copy of this grid if ``inplace=False``, or this
| DataSet if otherwise.
|
| See Also
| --------
| ExplicitStructuredGrid.compute_connections
| Compute an array with the number of connected cell faces.
|
| Examples
| --------
| >>> from pyvista import examples
| >>>
| >>> grid = examples.load_explicit_structured()
| >>> grid = grid.compute_connectivity()
| >>> grid.plot(show_edges=True)
|
| hide_cells(self, ind: 'VectorLike[int]', inplace: 'bool' = False) -> 'Self'
| Hide specific cells.
|
| Hides cells by setting the ghost cell array to ``HIDDENCELL``.
|
| Parameters
| ----------
| ind : sequence[int]
| Cell indices to be hidden. A boolean array of the same
| size as the number of cells also is acceptable.
|
| inplace : bool, default: False
| This method is applied to this grid if ``True``
| or to a copy otherwise.
|
| Returns
| -------
| output : ExplicitStructuredGrid | None
| A deep copy of this grid if ``inplace=False`` with the
| hidden cells, or this grid with the hidden cells if
| otherwise.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid = grid.hide_cells(range(80, 120))
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| neighbors(self, ind: 'int | VectorLike[int]', rel: 'str' = 'connectivity') -> 'list[int]'
| Return the indices of neighboring cells.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell IDs.
|
| rel : str, default: "connectivity"
| Defines the neighborhood relationship. If
| ``'topological'``, returns the ``(i-1, j, k)``, ``(i+1, j,
| k)``, ``(i, j-1, k)``, ``(i, j+1, k)``, ``(i, j, k-1)``
| and ``(i, j, k+1)`` cells. If ``'connectivity'``
| (default), returns only the topological neighbors
| considering faces connectivity. If ``'geometric'``,
| returns the cells in the ``(i-1, j)``, ``(i+1, j)``,
| ``(i,j-1)`` and ``(i, j+1)`` vertical cell groups whose
| faces intersect.
|
| Returns
| -------
| list[int]
| Indices of neighboring cells.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> cell = grid.extract_cells(31)
| >>> ind = grid.neighbors(31)
| >>> neighbors = grid.extract_cells(ind)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_axes()
| >>> _ = pl.add_mesh(cell, color='r', show_edges=True)
| >>> _ = pl.add_mesh(neighbors, color='w', show_edges=True)
| >>> pl.show()
|
| save(self, filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this VTK object to file.
|
| Parameters
| ----------
| filename : Path, str
| Output file name. VTU and VTK extensions are supported.
|
| binary : bool, default: True
| If ``True``, write as binary, else ASCII.
|
| texture : np.ndarray, str, None
| Ignored argument. Kept to maintain compatibility with supertype.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. When
| the target extension dispatches to a built-in VTK writer or
| to the pickle path, passing any extra keyword arguments
| raises :class:`TypeError`.
|
| .. versionadded:: 0.48
|
| Notes
| -----
| VTK adds the ``'BLOCK_I'``, ``'BLOCK_J'`` and ``'BLOCK_K'``
| cell arrays. These arrays are required to restore the explicit
| structured grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured() # doctest:+SKIP
| >>> grid = grid.hide_cells(range(80, 120)) # doctest:+SKIP
| >>> grid.save('grid.vtu') # doctest:+SKIP
|
| >>> grid = pv.ExplicitStructuredGrid('grid.vtu') # doctest:+SKIP
| >>> grid.plot(color='w', show_edges=True, show_bounds=True) # doctest:+SKIP
|
| >>> grid.show_cells() # doctest:+SKIP
| >>> grid.plot(color='w', show_edges=True, show_bounds=True) # doctest:+SKIP
|
| show_cells(self, inplace: 'bool' = False) -> 'Self'
| Show hidden cells.
|
| Shows hidden cells by setting the ghost cell array to ``0``
| where ``HIDDENCELL``.
|
| Parameters
| ----------
| inplace : bool, default: False
| This method is applied to this grid if ``True``
| or to a copy otherwise.
|
| Returns
| -------
| ExplicitStructuredGrid
| A deep copy of this grid if ``inplace=False`` with the
| hidden cells shown. Otherwise, this dataset with the
| shown cells.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid = grid.hide_cells(range(80, 120))
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| >>> grid = grid.show_cells()
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| dimensions
| Return the topological dimensions of the grid.
|
| Returns
| -------
| tuple[int, int, int]
| Number of sampling points in the I, J and Z directions respectively.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid.dimensions
| (5, 6, 7)
|
| visible_bounds
| Return the bounding box of the visible cells.
|
| Different from `bounds`, which returns the bounding box of the
| complete grid, this method returns the bounding box of the
| visible cells, where the ghost cell array is not
| ``HIDDENCELL``.
|
| Returns
| -------
| tuple[float, float, float]
| The limits of the visible grid in the X, Y and Z
| directions respectively.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid = grid.hide_cells(range(80, 120))
| >>> grid.bounds
| BoundsTuple(x_min = 0.0,
| x_max = 80.0,
| y_min = 0.0,
| y_max = 50.0,
| z_min = 0.0,
| z_max = 6.0)
|
| >>> grid.visible_bounds
| BoundsTuple(x_min = 0.0,
| x_max = 80.0,
| y_min = 0.0,
| y_max = 50.0,
| z_min = 0.0,
| z_max = 4.0)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| ----------------------------------------------------------------------
| Methods inherited from PointGrid:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| plot_curvature(self: 'Self', curv_type='mean', **kwargs)
| Plot the curvature of the external surface of the grid.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| One of the following strings indicating curvature types.
| - ``'mean'``
| - ``'gaussian'``
| - ``'maximum'``
| - ``'minimum'``
|
| **kwargs : dict, optional
| Optional keyword arguments. See :func:`pyvista.plot`.
|
| Returns
| -------
| list
| Camera position, focal point, and view up. Returned when
| ``return_cpos`` is ``True``.
|
| ----------------------------------------------------------------------
| Methods inherited from _PointSet:
|
| center_of_mass(self, scalars_weight: 'bool' = False) -> 'NumpyArray[float]'
| Return the coordinates for the center of mass of the mesh.
|
| Parameters
| ----------
| scalars_weight : bool, default: False
| Flag for using the mesh scalars as weights.
|
| Returns
| -------
| numpy.ndarray
| Coordinates for the center of mass.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 1, 1))
| >>> mesh.center_of_mass()
| array([1., 1., 1.])
|
| points_to_double(self) -> 'Self'
| Convert the points datatype to double precision.
|
| Returns
| -------
| pyvista.PointSet
| Pointset with points in double precision.
|
| Notes
| -----
| This operates in place.
|
| Examples
| --------
| Create a mesh that has points of the type ``float32`` and
| convert the points to ``float64``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.points.dtype
| dtype('float32')
| >>> _ = mesh.points_to_double()
| >>> mesh.points.dtype
| dtype('float64')
|
| remove_cells(self, ind: 'VectorLike[bool] | VectorLike[int]', inplace: 'bool' = False) -> '_PointSet'
| Remove cells.
|
| Parameters
| ----------
| ind : VectorLike[int] | VectorLike[bool]
| Cell indices to be removed. The array can also be a
| boolean array of the same size as the number of cells.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| Returns
| -------
| pyvista.DataSet
| Same type as the input, but with the specified cells
| removed.
|
| See Also
| --------
| :ref:`ghost_cells_example`
|
| Examples
| --------
| Remove 20 cells from an unstructured grid.
|
| >>> from pyvista import examples
| >>> import pyvista as pv
| >>> hex_mesh = pv.read(examples.hexbeamfile)
| >>> removed = hex_mesh.remove_cells(range(10, 20))
| >>> removed.plot(color='lightblue', show_edges=True, line_width=3)
|
| shallow_copy(self, to_copy: 'DataSet') -> 'None'
| Create a shallow copy from a different dataset into this one.
|
| This method mutates this dataset and returns ``None``.
|
| Parameters
| ----------
| to_copy : pyvista.DataSet
| Data object to perform the shallow copy from.
|
| translate(self: 'Self', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False)
| Translate the mesh.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats of cartesian values to translate the mesh with.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed. This is
| only valid when not updating in place.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PointSet
| Translated pointset.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=True)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkExplicitStructuredGrid:
|
| BlankCell(...)
| BlankCell(self, cellId:int) -> None
| C++: void BlankCell(vtkIdType cellId)
|
| Methods for supporting blanking of cells. Blanking turns on or
| off cells in the structured grid. These methods should be called
| only after the dimensions of the grid are set.
|
| BuildLinks(...)
| BuildLinks(self) -> None
| C++: void BuildLinks()
|
| Build topological links from points to lists of cells that use
| each point. See vtkAbstractCellLinks for more information.
|
| CheckAndReorderFaces(...)
| CheckAndReorderFaces(self) -> None
| C++: void CheckAndReorderFaces()
|
| Check faces are numbered correctly regarding ijk numbering If not
| this will reorganize cell points order so face order is valid.
| This is made in two pass, first it check that faces are on the
| correct axis and corrects it Then it check if faces are mirrored
| and corrects it. Make sure cells and extent have been set before
| calling this method and recompute face connectivity afterwards.
|
| ComputeCellId(...)
| ComputeCellId(self, i:int, j:int, k:int,
| adjustForExtent:bool=True) -> int
| C++: vtkIdType ComputeCellId(int i, int j, int k,
| bool adjustForExtent=true)
|
| Given a location in structured coordinates (i-j-k), return the
| cell id. If adjustForExtent is true, (i,j,k) is interpreted as a
| position relative to the beginning of the extent. If
| adjustForExtent is false, (i,j,k) is interpreted literally and
| the cell id is returned regardless of the extent beginning. The
| default adjustForExtent is true.
|
| ComputeCellStructuredCoords(...)
| ComputeCellStructuredCoords(self, cellId:int, i:int, j:int, k:int,
| adjustForExtent:bool=True) -> None
| C++: void ComputeCellStructuredCoords(vtkIdType cellId, int &i,
| int &j, int &k, bool adjustForExtent=true)
|
| Given a cellId, get the structured coordinates (i-j-k). If
| adjustForExtent is true, (i,j,k) is computed as a position
| relative to the beginning of the extent. If adjustForExtent is
| false, (i,j,k) is computed regardless of the extent beginning.
| The default adjustForExtent is true.
|
| ComputeFacesConnectivityFlagsArray(...)
| ComputeFacesConnectivityFlagsArray(self) -> None
| C++: void ComputeFacesConnectivityFlagsArray()
|
| Compute the faces connectivity flags array. This method should be
| called after the construction if the ESG is to be used by other
| filters.
|
| CopyStructure(...)
| CopyStructure(self, ds:vtkDataSet) -> None
| C++: void CopyStructure(vtkDataSet *ds) override;
|
| Copy the geometric and topological structure of an input poly
| data object.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: void Crop(const int *updateExtent) override;
| Crop(self, input:vtkExplicitStructuredGrid, updateExtent:(int,
| ...), generateOriginalCellIds:bool) -> None
| C++: virtual void Crop(vtkExplicitStructuredGrid *input,
| const int *updateExtent, bool generateOriginalCellIds)
|
| Reallocates and copies to set the Extent to the UpdateExtent.
| This is used internally when the exact extent is requested, and
| the source generated more than the update extent.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| GenerateGhostArray(...)
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int],
| cellOnly:bool) -> None
| C++: void GenerateGhostArray(int zeroExt[6], bool cellOnly)
| override;
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int])
| -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6])
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kilobytes. This number is
| valid only after the pipeline has updated. The memory size
| returned is guaranteed to be greater than or equal to the memory
| required to represent the data (e.g., extra space in arrays, etc.
| are not included in the return value). THIS METHOD IS THREAD
| SAFE.
|
| GetCell(...)
| GetCell(self, cellId:int) -> vtkCell
| C++: vtkCell *GetCell(vtkIdType cellId) override;
| GetCell(self, cellId:int, cell:vtkGenericCell) -> None
| C++: void GetCell(vtkIdType cellId, vtkGenericCell *cell)
| override;
| GetCell(self, i:int, j:int, k:int) -> vtkCell
| C++: virtual vtkCell *GetCell(int i, int j, int k)
|
| This method always return a `vtkEmptyCell`, as there is no cell
| in a `vtkPointSet`.
|
| GetCellBounds(...)
| GetCellBounds(self, cellId:int, bounds:[float, float, float,
| float, float, float]) -> None
| C++: void GetCellBounds(vtkIdType cellId, double bounds[6])
| override;
|
| Get the bounds of the cell with cellId such that: 0 <= cellId <
| NumberOfCells. A subclass may be able to determine the bounds of
| cell without using an expensive GetCell() method. A default
| implementation is provided that actually uses a GetCell() call.
| This is to ensure the method is available to all datasets.
| Subclasses should override this method to provide an efficient
| implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetCellDims(...)
| GetCellDims(self, cellDims:[int, int, int]) -> None
| C++: void GetCellDims(int cellDims[3])
|
| Computes the cell dimensions according to internal point
| dimensions. The total number of cells can be achieved simply by
| cellDims[0] * cellDims[1] * cellDims[2].
|
| GetCellNeighbors(...)
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds) override;
| GetCellNeighbors(self, cellId:int, neighbors:[int, int, int, int,
| int, int], wholeExtent:[int, ...]=...) -> None
| C++: void GetCellNeighbors(vtkIdType cellId,
| vtkIdType neighbors[6], int *wholeExtent=nullptr)
|
| Topological inquiry to get all cells using list of points
| exclusive of cell specified (e.g., cellId). Note that the list
| consists of only cells that use ALL the points provided. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetCellPoints(...)
| GetCellPoints(self, cellId:int, ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
| override;
| GetCellPoints(self, cellId:int) -> Pointer
| C++: vtkIdType *GetCellPoints(vtkIdType cellId)
| GetCellPoints(self, cellId:int, npts:int, pts:[int, ...]) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType *&pts)
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...),
| ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts, vtkIdList *ptIds) override;
|
| Topological inquiry to get points defining cell. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| GetCellSize(...)
| GetCellSize(self, cellId:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType cellId) override;
|
| This method always returns 1, as all cells are point in a pure
| `vtkPointSet`.
|
| GetCellType(...)
| GetCellType(self, cellId:int) -> int
| C++: int GetCellType(vtkIdType cellId) override;
|
| This method always returns `VTK_EMPTY_CELL`, as there is no cell
| in a `vtkPointSet`.
|
| GetCells(...)
| GetCells(self) -> vtkCellArray
| C++: virtual vtkCellArray *GetCells()
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkExplicitStructuredGrid
| C++: static vtkExplicitStructuredGrid *GetData(
| vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0)
| -> vtkExplicitStructuredGrid
| C++: static vtkExplicitStructuredGrid *GetData(
| vtkInformationVector *v, int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataDimension(...)
| GetDataDimension(self) -> int
| C++: int GetDataDimension()
|
| Return the dimensionality of the data.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return what type of dataset this is.
|
| GetDimensions(...)
| GetDimensions(self, dim:[int, int, int]) -> None
| C++: void GetDimensions(int dim[3])
|
| GetExtent(...)
| GetExtent(self) -> (int, int, int, int, int, int)
| C++: virtual int *GetExtent()
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: int GetExtentType() override;
|
| The extent type is a 3D extent
|
| GetFacesConnectivityFlagsArrayName(...)
| GetFacesConnectivityFlagsArrayName(self) -> str
| C++: virtual char *GetFacesConnectivityFlagsArrayName()
|
| GetLinks(...)
| GetLinks(self) -> vtkAbstractCellLinks
| C++: virtual vtkAbstractCellLinks *GetLinks()
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Convenience method returns largest cell size in dataset. This is
| generally used to allocate memory for supporting data structures.
| THIS METHOD IS THREAD SAFE
|
| GetMaxSpatialDimension(...)
| GetMaxSpatialDimension(self) -> int
| C++: int GetMaxSpatialDimension() override;
|
| Get the maximum/minimum spatial dimensionality of the data which
| is the maximum/minimum dimension of all cells.
|
| @warning This method MUST be overridden for performance reasons.
| Default implementation is very inefficient.
|
| GetMinSpatialDimension(...)
| GetMinSpatialDimension(self) -> int
| C++: int GetMinSpatialDimension() override;
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| This method always returns 0, as there are no cells in a
| `vtkPointSet`.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetPointCells(...)
| GetPointCells(self, ptId:int, cellIds:vtkIdList) -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
| override;
|
| Topological inquiry to get cells using point. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| HasAnyBlankCells(...)
| HasAnyBlankCells(self) -> bool
| C++: bool HasAnyBlankCells() override;
|
| Returns true if one or more cells are blanked, false otherwise.
|
| HasAnyGhostCells(...)
| HasAnyGhostCells(self) -> bool
| C++: bool HasAnyGhostCells()
|
| Returns true if one or more cells are ghost, false otherwise.
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Standard vtkDataSet API methods. See vtkDataSet for more
| information.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsCellGhost(...)
| IsCellGhost(self, cellId:int) -> int
| C++: unsigned char IsCellGhost(vtkIdType cellId)
|
| Return non-zero value if specified cell is a ghost cell. These
| methods should be called only after the dimensions of the grid
| are set.
|
| IsCellVisible(...)
| IsCellVisible(self, cellId:int) -> int
| C++: unsigned char IsCellVisible(vtkIdType cellId)
|
| Return non-zero value if specified cell is visible. These methods
| should be called only after the dimensions of the grid are set.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkExplicitStructuredGrid
| C++: vtkExplicitStructuredGrid *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkExplicitStructuredGrid
| C++: static vtkExplicitStructuredGrid *SafeDownCast(
| vtkObjectBase *o)
|
| SetCells(...)
| SetCells(self, _arg:vtkCellArray) -> None
| C++: virtual void SetCells(vtkCellArray *_arg)
|
| Set/Get the cell array defining hexahedron.
|
| SetDimensions(...)
| SetDimensions(self, i:int, j:int, k:int) -> None
| C++: void SetDimensions(int i, int j, int k)
| SetDimensions(self, dim:[int, int, int]) -> None
| C++: void SetDimensions(int dim[3])
|
| Set/Get the dimensions of this structured dataset in term of
| number of points along each direction. This is just a convenience
| method which calls Set/GetExtent internally.
|
| SetExtent(...)
| SetExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int, z1:int)
| -> None
| C++: void SetExtent(int x0, int x1, int y0, int y1, int z0,
| int z1)
| SetExtent(self, extent:[int, int, int, int, int, int]) -> None
| C++: void SetExtent(int extent[6])
|
| Set/Get the extent of this structured dataset in term of number
| of points along each direction. Setting the extent will reset the
| internal CellArray and Links and a correctly sized cell array
| will be created. The Extent is stored in the order (X, Y, Z).
|
| SetFacesConnectivityFlagsArrayName(...)
| SetFacesConnectivityFlagsArrayName(self, _arg:str) -> None
| C++: virtual void SetFacesConnectivityFlagsArrayName(
| const char *_arg)
|
| Set/Get the name of the faces connectivity flags array.
|
| SetLinks(...)
| SetLinks(self, _arg:vtkAbstractCellLinks) -> None
| C++: virtual void SetLinks(vtkAbstractCellLinks *_arg)
|
| Set/Get the links that you created possibly without using
| BuildLinks.
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| UnBlankCell(...)
| UnBlankCell(self, cellId:int) -> None
| C++: void UnBlankCell(vtkIdType cellId)
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkExplicitStructuredGrid:
|
| __this__
| Pointer to the C++ object.
|
| cells
| read-write, calls GetCells/SetCells
|
| data_dimension
| read-only, calls GetDataDimension
|
| data_object_type
| read-only, calls GetDataObjectType
|
| extent
| read-write, calls GetExtent/SetExtent
|
| extent_type
| read-only, calls GetExtentType
|
| faces_connectivity_flags_array_name
| read-write, calls GetFacesConnectivityFlagsArrayName/SetFacesConnectivityFlagsArrayName
|
| links
| read-write, calls GetLinks/SetLinks
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| max_spatial_dimension
| read-only, calls GetMaxSpatialDimension
|
| min_spatial_dimension
| read-only, calls GetMinSpatialDimension
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkExplicitStructuredGrid:
|
| __vtkname__ = 'vtkExplicitStructuredGrid'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| BuildCellLocator(...)
| BuildCellLocator(self) -> None
| C++: void BuildCellLocator()
|
| Build the cell locator. In a multi-threaded environment, call
| this method in a single thread before using FindCell().
|
| BuildLocator(...)
| BuildLocator(self) -> None
| C++: void BuildLocator()
|
| BuildPointLocator(...)
| BuildPointLocator(self) -> None
| C++: void BuildPointLocator()
|
| Build the internal point locator . In a multi-threaded
| environment, call this method in a single thread before using
| FindCell() or FindPoint().
|
| ComputeBounds(...)
| ComputeBounds(self) -> None
| C++: void ComputeBounds() override;
|
| Compute the (X, Y, Z) bounds of the data.
|
| EditableOff(...)
| EditableOff(self) -> None
| C++: virtual void EditableOff()
|
| EditableOn(...)
| EditableOn(self) -> None
| C++: virtual void EditableOn()
|
| ExtendedNew(...)
| ExtendedNew() -> vtkPointSet
| C++: static vtkPointSet *ExtendedNew()
|
| FindCell(...)
| FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int,
| tol2:float, subId:int, pcoords:[float, float, float],
| weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
| FindCell(self, x:[float, float, float], cell:vtkCell,
| gencell:vtkGenericCell, cellId:int, tol2:float, subId:int,
| pcoords:[float, float, float], weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkGenericCell *gencell, vtkIdType cellId, double tol2,
| int &subId, double pcoords[3], double *weights) override;
|
| Locate cell based on global coordinate x and tolerance squared.
| If cell and cellId is non-nullptr, then search starts from this
| cell and looks at immediate neighbors. Returns cellId >= 0 if
| inside, < 0 otherwise. The parametric coordinates are provided
| in pcoords[3]. The interpolation weights are returned in
| weights[]. (The number of weights is equal to the number of
| points in the found cell). Tolerance is used to control how close
| the point is to be considered "in" the cell. THIS METHOD IS NOT
| THREAD SAFE.
|
| FindPoint(...)
| FindPoint(self, x:[float, float, float]) -> int
| C++: vtkIdType FindPoint(double x[3]) override;
|
| GetCellLocator(...)
| GetCellLocator(self) -> vtkAbstractCellLocator
| C++: virtual vtkAbstractCellLocator *GetCellLocator()
|
| GetEditable(...)
| GetEditable(self) -> bool
| C++: virtual bool GetEditable()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Get MTime which also considers its vtkPoints MTime.
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| See vtkDataSet for additional information.
|
| GetPoint(...)
| GetPoint(self, ptId:int, x:[float, float, float]) -> None
| C++: void GetPoint(vtkIdType ptId, double x[3]) override;
| GetPoint(self, ptId:int) -> (float, float, float)
| C++: double *GetPoint(vtkIdType ptId) override;
|
| Copy point coordinates into user provided array x[3] for
| specified point id. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetPointLocator(...)
| GetPointLocator(self) -> vtkAbstractPointLocator
| C++: virtual vtkAbstractPointLocator *GetPointLocator()
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints() override;
|
| If the subclass has (implicit/explicit) points, then return them.
| Otherwise, create a vtkPoints object and return that.
|
| DO NOT MODIFY THE RETURNED POINTS OBJECT.
|
| NewCellIterator(...)
| NewCellIterator(self) -> vtkCellIterator
| C++: vtkCellIterator *NewCellIterator() override;
|
| Return an iterator that traverses the cells in this data set.
|
| SetCellLocator(...)
| SetCellLocator(self, __a:vtkAbstractCellLocator) -> None
| C++: virtual void SetCellLocator(vtkAbstractCellLocator *)
|
| Set / get an instance of vtkAbstractCellLocator which may be used
| when a vtkCellLocatorStrategy is used during a FindCell()
| operation.
|
| SetEditable(...)
| SetEditable(self, _arg:bool) -> None
| C++: virtual void SetEditable(bool _arg)
|
| Specify whether this dataset is editable after creation. Meaning,
| once the points and cells are defined, can the dataset be
| incrementally modified. By default, this dataset is non-editable
| (i.e., "static") after construction. The reason for this is
| performance: cell links and locators can be built (and destroyed)
| much faster is it is known that the data is static (see
| vtkStaticCellLinks, vtkStaticPointLocator, vtkStaticCellLocator).
|
| SetPointLocator(...)
| SetPointLocator(self, __a:vtkAbstractPointLocator) -> None
| C++: virtual void SetPointLocator(vtkAbstractPointLocator *)
|
| Set / get an instance of vtkAbstractPointLocator which is used to
| support the FindPoint() and FindCell() methods. By default a
| vtkStaticPointLocator is used, unless the class is set as
| Editable, in which case a vtkPointLocator is used.
|
| SetPoints(...)
| SetPoints(self, __a:vtkPoints) -> None
| C++: virtual void SetPoints(vtkPoints *)
|
| Specify point array to define point coordinates.
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: void Squeeze() override;
|
| Reclaim any unused memory.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Overwritten to handle the data/locator loop
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| cell_locator
| read-write, calls GetCellLocator/SetCellLocator
|
| editable
| read-write, calls GetEditable/SetEditable
|
| m_time
| read-only, calls GetMTime
|
| point_locator
| read-write, calls GetPointLocator/SetPointLocator
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| AllocateCellGhostArray(...)
| AllocateCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocateCellGhostArray()
|
| Allocate ghost array for cells.
|
| AllocatePointGhostArray(...)
| AllocatePointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocatePointGhostArray()
|
| Allocate ghost array for points.
|
| CheckAttributes(...)
| CheckAttributes(self) -> int
| C++: int CheckAttributes()
|
| This method checks to see if the cell and point attributes match
| the geometry. Many filters will crash if the number of tuples in
| an array is less than the number of points/cells. This method
| returns 1 if there is a mismatch, and 0 if everything is ok. It
| prints an error if an array is too short, and a warning if an
| array is too long.
|
| CopyAttributes(...)
| CopyAttributes(self, ds:vtkDataSet) -> None
| C++: virtual void CopyAttributes(vtkDataSet *ds)
|
| Copy the attributes associated with the specified dataset to this
| instance of vtkDataSet. THIS METHOD IS NOT THREAD SAFE.
|
| FindAndGetCell(...)
| FindAndGetCell(self, x:[float, float, float], cell:vtkCell,
| cellId:int, tol2:float, subId:int, pcoords:[float, float,
| float], weights:[float, ...]) -> vtkCell
| C++: virtual vtkCell *FindAndGetCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights)
|
| Locate the cell that contains a point and return the cell. Also
| returns the subcell id, parametric coordinates and weights for
| subsequent interpolation. This method combines the derived class
| methods int FindCell and vtkCell *GetCell. Derived classes may
| provide a more efficient implementation. See for example
| vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return a pointer to the geometry bounding box in the form
| (xmin,xmax, ymin,ymax, zmin,zmax). THIS METHOD IS NOT THREAD
| SAFE.
|
| GetCellData(...)
| GetCellData(self) -> vtkCellData
| C++: vtkCellData *GetCellData()
|
| Return a pointer to this dataset's cell data. THIS METHOD IS
| THREAD SAFE
|
| GetCellGhostArray(...)
| GetCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellGhostArray()
|
| Get the array that defines the ghost type of each cell. We cache
| the pointer to the array to save a lookup involving string
| comparisons
|
| GetCellNumberOfFaces(...)
| GetCellNumberOfFaces(self, cellId:int, cellType:int,
| cell:vtkGenericCell) -> int
| C++: virtual int GetCellNumberOfFaces(vtkIdType cellId,
| unsigned char &cellType, vtkGenericCell *cell)
|
| Get the number of faces of a cell.
|
| Most of the times extracting the number of faces requires only
| extracting the cell type. However, for some cell types, the
| number of faces is not constant. For example, a convex point set
| cell can have a different number of faces for each cell. That's
| why this method requires the cell id and the dataset.
|
| GetCellTypes(...)
| GetCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetCellTypes(vtkCellTypes *types)
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: double *GetCenter()
| GetCenter(self, center:[float, float, float]) -> None
| C++: void GetCenter(double center[3])
|
| Get the center of the bounding box. THIS METHOD IS NOT THREAD
| SAFE.
|
| GetDistinctCellTypes(...)
| GetDistinctCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetDistinctCellTypes(vtkCellTypes *types)
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset 5 triangles, 3 lines, and
| 100 hexahedra would result a list of three entries, corresponding
| to the types VTK_TRIANGLE, VTK_LINE, and VTK_HEXAHEDRON. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetGhostArray(int type) override;
|
| Returns the ghost array for the given type (point or cell). Takes
| advantage of the cache with the pointer to the array to save a
| string comparison.
|
| GetLength(...)
| GetLength(self) -> float
| C++: double GetLength()
|
| Return the length of the diagonal of the bounding box. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Return the squared length of the diagonal of the bounding box.
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetMeshMTime(...)
| GetMeshMTime(self) -> int
| C++: virtual vtkMTimeType GetMeshMTime()
|
| Abstract method which return the mesh (geometry/topology)
| modification time. This time is different from the usual MTime
| which also takes into account the modification of data arrays.
| This function can be used to track the changes on the mesh
| separately from the data arrays (eg. static mesh over time with
| transient data). The default implementation returns the MTime. It
| is up to subclasses to provide a better approach.
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| GetPointData(...)
| GetPointData(self) -> vtkPointData
| C++: vtkPointData *GetPointData()
|
| Return a pointer to this dataset's point data. THIS METHOD IS
| THREAD SAFE
|
| GetPointGhostArray(...)
| GetPointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetPointGhostArray()
|
| Gets the array that defines the ghost type of each point. We
| cache the pointer to the array to save a lookup involving string
| comparisons
|
| GetScalarRange(...)
| GetScalarRange(self, range:[float, float]) -> None
| C++: virtual void GetScalarRange(double range[2])
| GetScalarRange(self) -> (float, float)
| C++: double *GetScalarRange()
|
| Convenience method to get the range of the first component (and
| only the first component) of any scalars in the data set. If the
| data has both point data and cell data, it returns the (min/max)
| range of combined point and cell data. If there are no point or
| cell scalars the method will return (0,1). Note: It might be
| necessary to call Update to create or refresh the scalars before
| calling this method. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| HasAnyBlankPoints(...)
| HasAnyBlankPoints(self) -> bool
| C++: virtual bool HasAnyBlankPoints()
|
| Returns 1 if there are any blanking points 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyGhostPoints(...)
| HasAnyGhostPoints(self) -> bool
| C++: bool HasAnyGhostPoints()
|
| Returns 1 if there are any ghost points 0 otherwise.
|
| SetCellOrderAndRationalWeights(...)
| SetCellOrderAndRationalWeights(self, cellId:int,
| cell:vtkGenericCell) -> None
| C++: void SetCellOrderAndRationalWeights(vtkIdType cellId,
| vtkGenericCell *cell)
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| cell_ghost_array
| read-only, calls GetCellGhostArray
|
| length2
| read-only, calls GetLength2
|
| mesh_m_time
| read-only, calls GetMeshMTime
|
| point_ghost_array
| read-only, calls GetPointGhostArray
|
| scalar_range
| read-only, calls GetScalarRange
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| CELL_DATA_FIELD = 2
|
| DATA_OBJECT_FIELD = 0
|
| FieldDataType = <class 'vtkmodules.vtkCommonDataModel.vtkDataSet.Field...
|
| POINT_DATA_FIELD = 1
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.FIGURE_PATH
Python Library Documentation: NoneType object class NoneType(object) | Methods defined here: | | __bool__(self, /) | True if self else False | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) | Create and return a new object. See help(type) for accurate signature.
pyvista.FLOAT_FORMAT
Error rendering doc: No Python documentation found for '{:.3e}'.
Use help() to get the interactive help utility.
Use help(str) for help on the str class.
pyvista.FLUENTCFFReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.FRDReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.FacetReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.FieldAssociation
Python Library Documentation: class FieldAssociation in module pyvista.core.utilities.arrays class FieldAssociation(enum.Enum) | FieldAssociation(*values) | | Represents which type of vtk field a scalar or vector array is associated with. | | Method resolution order: | FieldAssociation | enum.Enum | builtins.object | | Data and other attributes defined here: | | CELL = <FieldAssociation.CELL: 1> | | NONE = <FieldAssociation.NONE: 2> | | POINT = <FieldAssociation.POINT: 0> | | ROW = <FieldAssociation.ROW: 6> | | ---------------------------------------------------------------------- | Data descriptors inherited from enum.Enum: | | name | The name of the Enum member. | | value | The value of the Enum member. | | ---------------------------------------------------------------------- | Static methods inherited from enum.EnumType: | | __contains__(value) | Return True if `value` is in `cls`. | | `value` is in `cls` if: | 1) `value` is a member of `cls`, or | 2) `value` is the value of one of the `cls`'s members. | | __getitem__(name) | Return the member matching `name`. | | __iter__() | Return members in definition order. | | __len__() | Return the number of members (no aliases) | | ---------------------------------------------------------------------- | Readonly properties inherited from enum.EnumType: | | __members__ | Returns a mapping of member name->value. | | This mapping lists all enum members, including aliases. Note that this | is a read-only view of the internal mapping.
pyvista.FluentReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.GESignaReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.GIFReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.GLTFReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.GPUInfo
Python Library Documentation: class GPUInfo in module pyvista.report class GPUInfo(builtins.object) | A class to hold GPU details. | | Methods defined here: | | __init__(self) | Instantiate a container for the GPU information. | | __repr__(self) | Representation method. | | __str__(self) | Return a human-readable string representation. | | get_info(self) | All GPU information as tuple pairs. | | Returns | ------- | tuple | Tuples of ``(key, info)``. | | ---------------------------------------------------------------------- | Readonly properties defined here: | | renderer | GPU renderer name. | | vendor | GPU renderer vendor. | | version | GPU renderer version. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object
pyvista.GambitReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.GaussianCubeReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.Grid
Python Library Documentation: class Grid in module pyvista.core.grid
class Grid(pyvista.core.dataset.DataSet)
| Grid(*args, **kwargs) -> '_T'
|
| A class full of common methods for non-pointset grids.
|
| Method resolution order:
| Grid
| pyvista.core.dataset.DataSet
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| builtins.object
|
| Methods defined here:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| to_hexahedra(self: 'Self') -> 'UnstructuredGrid'
| Convert voxels to hexahedra.
|
| Convert this mesh to :class:`~pyvista.UnstructuredGrid` with
| :attr:`~pyvista.CellType.HEXAHEDRON` cells. Equivalent to
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` except the output has
| hexahedra instead of :attr:`~pyvista.CellType.VOXEL` cells.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with :attr:`~pyvista.CellType.HEXAHEDRON` cells.
|
| Raises
| ------
| ValueError
| If the input is not 3-dimensional.
|
| See Also
| --------
| to_quads, to_tetrahedra
| pyvista.DataSet.cast_to_unstructured_grid
|
| Examples
| --------
| Convert a 3D :class:`~pyvista.ImageData` to hexahedra.
|
| >>> import pyvista as pv
| >>> image = pv.ImageData(dimensions=(2, 2, 2))
| >>> hexes = image.to_hexahedra()
| >>> hexes.distinct_cell_types == {pv.CellType.HEXAHEDRON}
| True
|
| to_quads(self: 'Self') -> 'UnstructuredGrid'
| Convert pixels to quads.
|
| Convert this mesh to :class:`~pyvista.UnstructuredGrid` with
| :attr:`~pyvista.CellType.QUAD` cells. Equivalent to
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` except the output has
| quads instead of :attr:`~pyvista.CellType.PIXEL` cells.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with :attr:`~pyvista.CellType.QUAD` cells.
|
| Raises
| ------
| ValueError
| If the input is not 2-dimensional.
|
| See Also
| --------
| to_hexahedra, to_tetrahedra
| pyvista.DataSet.cast_to_unstructured_grid
|
| Examples
| --------
| Convert a 2D :class:`~pyvista.ImageData` to quads.
|
| >>> import pyvista as pv
| >>> image = pv.ImageData(dimensions=(3, 2, 1))
| >>> quads = image.to_quads()
| >>> quads.distinct_cell_types == {pv.CellType.QUAD}
| True
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| dimensions
| Return the grid's dimensions.
|
| These are effectively the number of points along each of the
| three dataset axes.
|
| Returns
| -------
| tuple[int]
| Dimensions of the grid.
|
| Examples
| --------
| Create a uniform grid with dimensions ``(1, 2, 3)``.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(2, 3, 4))
| >>> grid.dimensions
| (2, 3, 4)
| >>> grid.plot(show_edges=True)
|
| Set the dimensions to ``(3, 4, 5)``
|
| >>> grid.dimensions = (3, 4, 5)
| >>> grid.plot(show_edges=True)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __init__(self: 'Self', *args, **kwargs) -> 'None'
| Initialize the common object.
|
| __repr__(self: 'Self') -> 'str'
| Return the object representation.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| __str__(self: 'Self') -> 'str'
| Return the object string representation.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
pyvista.HDFReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.HDFWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.HDRReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.HoudiniPolyDataWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.ID_TYPE
Python Library Documentation: class int64 in module numpy class int64(signedinteger) | Default signed integer type, 64bit on 64bit systems and 32bit on 32bit | systems. | | :Character code: ``'q'`` | :Canonical name: `numpy.int_` | :Alias on this platform (win32 AMD64): `numpy.int64`: 64-bit signed integer (``-9_223_372_036_854_775_808`` to ``9_223_372_036_854_775_807``). | :Alias on this platform (win32 AMD64): `numpy.intp`: Signed integer large enough to fit pointer, compatible with C ``intptr_t``. | | Method resolution order: | int64 | signedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | True if self else False | | __buffer__(self, flags, /) | Return a buffer object that exposes the underlying memory of the object. | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | bit_count(...) | int64.bit_count() -> int | | Computes the number of 1-bits in the absolute value of the input. | Analogous to the builtin `int.bit_count` or ``popcount`` in C++. | | Examples | -------- | >>> np.int64(127).bit_count() | 7 | >>> np.int64(-127).bit_count() | 7 | | ---------------------------------------------------------------------- | Class methods defined here: | | __class_getitem__(...) | __class_getitem__(item, /) | | Return a parametrized wrapper around the `~numpy.number` type. | | .. versionadded:: 1.22 | | Returns | ------- | alias : types.GenericAlias | A parametrized `~numpy.number` type. | | Examples | -------- | >>> from typing import Any | >>> import numpy as np | | >>> np.signedinteger[Any] | numpy.signedinteger[typing.Any] | | See Also | -------- | :pep:`585` : Type hinting generics in standard collections. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | is_integer(...) | integer.is_integer() -> bool | | Return ``True`` if the number is finite with integral value. | | .. versionadded:: 1.22 | | Examples | -------- | >>> import numpy as np | >>> np.int64(-2).is_integer() | True | >>> np.uint32(5).is_integer() | True | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_namespace__(...) | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.all`. | | any(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.any`. | | argmax(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.argmax`. | | argmin(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.argmin`. | | argsort(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.argsort`. | | astype(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.astype`. | | byteswap(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.byteswap`. | | choose(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.choose`. | | clip(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.clip`. | | compress(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.compress`. | | conj(...) | | conjugate(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.conjugate`. | | copy(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.copy`. | | cumprod(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.cumprod`. | | cumsum(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.cumsum`. | | diagonal(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.diagonal`. | | dump(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.dump`. | | dumps(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.dumps`. | | fill(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.fill`. | | flatten(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.flatten`. | | getfield(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.getfield`. | | item(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.item`. | | max(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.max`. | | mean(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.mean`. | | min(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.min`. | | nonzero(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.nonzero`. | | prod(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.prod`. | | put(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.put`. | | ravel(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.ravel`. | | repeat(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.repeat`. | | reshape(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.reshape`. | | resize(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.resize`. | | round(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.round`. | | searchsorted(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.searchsorted`. | | setfield(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.setfield`. | | setflags(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.setflags`. | | sort(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.sort`. | | squeeze(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.squeeze`. | | std(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.std`. | | sum(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.sum`. | | swapaxes(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.swapaxes`. | | take(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.take`. | | to_device(...) | | tobytes(...) | | tofile(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.tofile`. | | tolist(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.tolist`. | | tostring(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.tostring`. | | trace(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.trace`. | | transpose(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.transpose`. | | var(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.var`. | | view(...) | Scalar method identical to the corresponding array attribute. | | Please see `ndarray.view`. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | Scalar attribute identical to the corresponding array attribute. | | Please see `ndarray.T`. | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | Scalar attribute identical to the corresponding array attribute. | | Please see `ndarray.base`. | | data | Pointer to start of data. | | device | | dtype | Get array data-descriptor. | | flags | The integer value of flags. | | flat | A 1-D view of the scalar. | | imag | The imaginary part of the scalar. | | itemset | | itemsize | The length of one element in bytes. | | nbytes | | ndim | The number of array dimensions. | | newbyteorder | | ptp | | real | The real part of the scalar. | | shape | Tuple of array dimensions. | | size | The number of elements in the gentype. | | strides | Tuple of bytes steps in each dimension.
pyvista.IVWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.Icosahedron
Python Library Documentation: function Icosahedron in module pyvista.core.utilities.geometric_objects
Icosahedron(radius: 'float' = 1.0, center: 'VectorLike[float]' = (0.0, 0.0, 0.0)) -> 'PolyData'
Create an icosahedron of a given size.
An icosahedron is composed of twenty congruent equilateral
triangles.
Parameters
----------
radius : float, default: 1.0
The radius of the circumscribed sphere for the icosahedron.
center : sequence[float], default: (0.0, 0.0, 0.0)
Three-length sequence defining the center of the icosahedron.
Returns
-------
pyvista.PolyData
Mesh for the icosahedron. Cell scalars are defined that assign
integer labels to each face (with array name ``"FaceIndex"``).
Examples
--------
Create and plot an icosahedron.
>>> import pyvista as pv
>>> tetra = pv.Icosahedron()
>>> tetra.plot(categories=True)
See :ref:`create_platonic_solids_example` for more examples using this filter.
pyvista.Icosphere
Python Library Documentation: function Icosphere in module pyvista.core.utilities.geometric_objects
Icosphere(radius: 'float' = 1.0, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), nsub: 'int' = 3) -> 'PolyData'
Create an icosphere.
An icosphere is a `geodesic polyhedron
<https://en.wikipedia.org/wiki/Geodesic_polyhedron>`_, which is a
convex polyhedron made from triangles.
Geodesic polyhedra are constructed by subdividing faces of simpler
polyhedra, and then projecting the new vertices onto the surface of
a sphere. A geodesic polyhedron has straight edges and flat faces
that approximate a sphere,
Parameters
----------
radius : float, default: 1.0
Radius of the icosphere.
center : sequence[float], default: (0.0, 0.0, 0.0)
Center of the icosphere.
nsub : int, default: 3
This is the number of times each triangle of the original
:func:`pyvista.Icosahedron` is subdivided.
Returns
-------
pyvista.PolyData
Mesh of the icosphere.
See Also
--------
pyvista.Sphere
Examples
--------
Create the icosphere and plot it with edges.
>>> import pyvista as pv
>>> icosphere = pv.Icosphere()
>>> icosphere.plot(show_edges=True)
Show how this icosphere was created.
>>> import numpy as np
>>> icosahedron = pv.Icosahedron()
>>> icosahedron.clear_data() # remove extra scalars
>>> icosahedron_sub = icosahedron.subdivide(nsub=3)
>>> pl = pv.Plotter(shape=(1, 3))
>>> _ = pl.add_mesh(icosahedron, show_edges=True)
>>> pl.subplot(0, 1)
>>> _ = pl.add_mesh(icosahedron_sub, show_edges=True)
>>> pl.subplot(0, 2)
>>> _ = pl.add_mesh(icosphere, show_edges=True)
>>> pl.show()
Show how the triangles are not uniform in area. This is because the
ones farther from the edges from the original triangles have farther
to travel to the sphere.
>>> icosphere = pv.Icosphere(nsub=4)
>>> icosphere.compute_cell_sizes().plot(scalars='Area')
pyvista.ImageData
Python Library Documentation: class ImageData in module pyvista.core.grid
class ImageData(Grid, pyvista.core.filters.image_data.ImageDataFilters, vtkmodules.vtkCommonDataModel.vtkImageData)
| ImageData(*args, **kwargs) -> '_T'
|
| Models datasets with uniform spacing in the three coordinate directions.
|
| Can be initialized in one of several ways:
|
| - Create empty grid
| - Initialize from a :vtk:`vtkImageData` object
| - Initialize based on dimensions, cell spacing, and origin.
|
| .. versionchanged:: 0.33.0
| First argument must now be either a path or
| :vtk:`vtkImageData`. Use keyword arguments to specify the
| dimensions, spacing, and origin of the uniform grid.
|
| .. versionchanged:: 0.37.0
| The ``dims`` parameter has been renamed to ``dimensions``.
|
| Parameters
| ----------
| uinput : str | :vtk:`vtkImageData` | ImageData, optional
| Filename or dataset to initialize the uniform grid from. If
| set, remainder of arguments are ignored.
|
| dimensions : sequence[int], optional
| :attr:`dimensions` of the uniform grid.
|
| spacing : sequence[float], default: (1.0, 1.0, 1.0)
| :attr:`spacing` of the uniform grid in each dimension. Must be positive.
|
| origin : sequence[float], default: (0.0, 0.0, 0.0)
| :attr:`origin` of the uniform grid.
|
| deep : bool, default: False
| Whether to deep copy a :vtk:`vtkImageData` object. Keyword only.
|
| direction_matrix : RotationLike, optional
| The :attr:`direction_matrix` is a 3x3 matrix which controls the orientation of
| the image data.
|
| .. versionadded:: 0.45
|
| offset : int | VectorLike[int], default: (0, 0, 0)
| The offset defines the minimum :attr:`extent` of the image. Offset values
| can be positive or negative. In physical space, the offset is relative
| to the image's :attr:`origin`.
|
| .. versionadded:: 0.45
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| :ref:`create_uniform_grid_example`
|
| Examples
| --------
| Create an empty ImageData.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData()
|
| Initialize from a :vtk:`vtkImageData` object.
|
| >>> import vtk
| >>> vtkgrid = vtk.vtkImageData()
| >>> grid = pv.ImageData(vtkgrid)
|
| Initialize using just the grid dimensions and default
| spacing and origin. These must be keyword arguments.
|
| >>> grid = pv.ImageData(dimensions=(10, 10, 10))
|
| Initialize using dimensions and spacing.
|
| >>> grid = pv.ImageData(
| ... dimensions=(10, 10, 10),
| ... spacing=(2, 1, 5),
| ... )
|
| Initialize using dimensions, spacing, and an origin.
|
| >>> grid = pv.ImageData(
| ... dimensions=(10, 10, 10),
| ... spacing=(2, 1, 5),
| ... origin=(10, 35, 50),
| ... )
|
| Initialize from another ImageData.
|
| >>> grid = pv.ImageData(
| ... dimensions=(10, 10, 10),
| ... spacing=(2, 1, 5),
| ... origin=(10, 35, 50),
| ... )
| >>> grid_from_grid = pv.ImageData(grid)
| >>> grid_from_grid == grid
| True
|
| Method resolution order:
| ImageData
| Grid
| pyvista.core.dataset.DataSet
| pyvista.core.filters.image_data.ImageDataFilters
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkImageData
| vtkmodules.vtkCommonDataModel.vtkCartesianGrid
| vtkmodules.vtkCommonDataModel.vtkDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __getitem__(self, key: "tuple[str, Literal['cell', 'point', 'field']] | str | tuple[int, int, int]") -> 'ImageData | pyvista_ndarray'
| Search for a data array or slice with IJK indexing.
|
| __init__(self: 'Self', uinput: 'ImageData | str | Path | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'VectorLike[float]' = (1.0, 1.0, 1.0), origin: 'VectorLike[float]' = (0.0, 0.0, 0.0), deep: 'bool' = False, direction_matrix: 'RotationLike | None' = None, offset: 'int | VectorLike[int] | None' = None, *, validate: 'bool | _NestedMeshValidationFields' = False) -> 'None'
| Initialize the uniform grid.
|
| __repr__(self: 'Self') -> 'str'
| Return the default representation.
|
| __str__(self: 'Self') -> 'str'
| Return the default str representation.
|
| cast_to_rectilinear_grid(self: 'Self') -> 'RectilinearGrid'
| Cast this uniform grid to a rectilinear grid.
|
| Returns
| -------
| pyvista.RectilinearGrid
| This uniform grid as a rectilinear grid.
|
| cast_to_structured_grid(self: 'Self') -> 'StructuredGrid'
| Cast this image data to a :class:`~pyvista.StructuredGrid`.
|
| .. note::
|
| Casting converts :class:`~pyvista.CellType.PIXEL` cells to
| :class:`~pyvista.CellType.QUAD` cells for 2D inputs, and
| :class:`~pyvista.CellType.VOXEL` cells to :class:`~pyvista.CellType.HEXAHEDRON` cells
| for 3D inputs. To preserve cell type, use
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` instead.
|
| Returns
| -------
| pyvista.StructuredGrid
| This grid as a structured grid.
|
| to_tetrahedra(self, tetra_per_cell: 'int' = 5, mixed: 'str | Sequence[int] | bool' = False, pass_cell_ids: 'bool' = True, pass_data: 'bool' = True, progress_bar: 'bool' = False) from pyvista.core.filters.rectilinear_grid.RectilinearGridFilters
| Create a tetrahedral mesh structured grid.
|
| Parameters
| ----------
| tetra_per_cell : int, default: 5
| The number of tetrahedrons to divide each cell into. Can be
| either ``5``, ``6``, or ``12``. If ``mixed=True``, this value is
| overridden.
|
| mixed : str, bool, sequence, default: False
| When set, subdivides some cells into 5 and some cells into 12. Set
| to ``True`` to use the active cell scalars of the
| :class:`pyvista.RectilinearGrid` to be either 5 or 12 to
| determining the number of tetrahedra to generate per cell.
|
| When a sequence, uses these values to subdivide the cells. When a
| string uses a cell array rather than the active array to determine
| the number of tetrahedra to generate per cell.
|
| pass_cell_ids : bool, default: True
| Set to ``True`` to make the tetrahedra have scalar data indicating
| which cell they came from in the original
| :class:`pyvista.RectilinearGrid`. The name of this array is
| ``'vtkOriginalCellIds'`` within the ``cell_data``.
|
| pass_data : bool, default: True
| Set to ``True`` to make the tetrahedra mesh have the cell data from
| the original :class:`pyvista.RectilinearGrid`. This uses
| ``pass_cell_ids=True`` internally. If ``True``, ``pass_cell_ids``
| will also be set to ``True``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the tetrahedral cells.
|
| Examples
| --------
| Divide a rectangular grid into tetrahedrons. Each cell contains by
| default 5 tetrahedrons.
|
| First, create and plot the grid.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 2)
| >>> yrng = np.linspace(0, 1, 2)
| >>> zrng = np.linspace(0, 2, 3)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> grid.plot()
|
| Now, generate the tetrahedra plot in the exploded view of the cell.
|
| >>> tet_grid = grid.to_tetrahedra()
| >>> tet_grid.explode(factor=0.5).plot(show_edges=True)
|
| Take the same grid but divide the first cell into 5 cells and the other
| cell into 12 tetrahedrons per cell.
|
| >>> tet_grid = grid.to_tetrahedra(mixed=[5, 12])
| >>> tet_grid.explode(factor=0.5).plot(show_edges=True)
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| x
| Return all the X points.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(2, 2, 2))
| >>> grid.x
| array([0., 1., 0., 1., 0., 1., 0., 1.])
|
| y
| Return all the Y points.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(2, 2, 2))
| >>> grid.y
| array([0., 0., 1., 1., 0., 0., 1., 1.])
|
| z
| Return all the Z points.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(2, 2, 2))
| >>> grid.z
| array([0., 0., 0., 0., 1., 1., 1., 1.])
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| direction_matrix
| Set or get the direction matrix.
|
| The direction matrix is a 3x3 matrix which controls the orientation of the
| image data.
|
| .. versionadded:: 0.45
|
| Returns
| -------
| np.ndarray
| Direction matrix as a 3x3 NumPy array.
|
| extent
| Return or set the extent of the ImageData.
|
| The extent is simply the first and last indices for each of the three axes.
| It encodes information about the image's :attr:`offset` and :attr:`dimensions`.
|
| Examples
| --------
| Create a ``ImageData`` and show its extent.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(10, 10, 10))
| >>> grid.extent
| (0, 9, 0, 9, 0, 9)
|
| >>> grid.extent = (2, 5, 2, 5, 2, 5)
| >>> grid.extent
| (2, 5, 2, 5, 2, 5)
|
| Note how this also modifies the grid's :attr:`offset`, :attr:`dimensions`,
| and :attr:`bounds`. Since we use default spacing of 1 here, the bounds
| match the extent exactly.
|
| >>> grid.offset
| (2, 2, 2)
|
| >>> grid.dimensions
| (4, 4, 4)
|
| >>> grid.bounds
| BoundsTuple(x_min = 2.0,
| x_max = 5.0,
| y_min = 2.0,
| y_max = 5.0,
| z_min = 2.0,
| z_max = 5.0)
|
| index_to_physical_matrix
| Return or set 4x4 matrix to transform index space (ijk) to physical space (xyz).
|
| .. note::
| Setting this property modifies the object's :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and :class:`~pyvista.ImageData.direction_matrix`
| properties.
|
| .. versionadded:: 0.45
|
| Returns
| -------
| np.ndarray
| 4x4 transformation matrix.
|
| offset
| Return or set the index offset of the ImageData.
|
| The offset is simply the first indices for each of the three axes
| and defines the minimum :attr:`extent` of the image. Offset values
| can be positive or negative. In physical space, the offset is relative
| to the image's :attr:`origin`.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| Create a ``ImageData`` and show that the offset is zeros by default.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(10, 10, 10))
| >>> grid.offset
| (0, 0, 0)
|
| The offset defines the minimum extent.
|
| >>> grid.extent
| (0, 9, 0, 9, 0, 9)
|
| Set the offset to a new value for all axes.
|
| >>> grid.offset = 2
| >>> grid.offset
| (2, 2, 2)
|
| Show the extent again. Note how all values have increased by the offset value.
|
| >>> grid.extent
| (2, 11, 2, 11, 2, 11)
|
| Set the offset for each axis separately and show the extent again.
|
| >>> grid.offset = (-1, -2, -3)
| >>> grid.extent
| (-1, 8, -2, 7, -3, 6)
|
| origin
| Return the origin of the grid (bottom southwest corner).
|
| Examples
| --------
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> grid.origin
| (0.0, 0.0, 0.0)
|
| Show how the origin is in the bottom "southwest" corner of the
| ImageData.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(grid, show_edges=True)
| >>> _ = pl.add_axes_at_origin(ylabel=None)
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| Set the origin to ``(1, 1, 1)`` and show how this shifts the
| ImageData.
|
| >>> grid.origin = (1, 1, 1)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(grid, show_edges=True)
| >>> _ = pl.add_axes_at_origin(ylabel=None)
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| physical_to_index_matrix
| Return or set 4x4 matrix to transform from physical space (xyz) to index space (ijk).
|
| .. note::
| Setting this property modifies the object's :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and :class:`~pyvista.ImageData.direction_matrix`
| properties.
|
| .. versionadded:: 0.45
|
| Returns
| -------
| np.ndarray
| 4x4 transformation matrix.
|
| points
| Build a copy of the implicitly defined points as a numpy array.
|
| Returns
| -------
| numpy.ndarray
| Array of points representing the image data.
|
| Notes
| -----
| The ``points`` for a :class:`pyvista.ImageData` cannot be set.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(2, 2, 2))
| >>> grid.points
| array([[0., 0., 0.],
| [1., 0., 0.],
| [0., 1., 0.],
| [1., 1., 0.],
| [0., 0., 1.],
| [1., 0., 1.],
| [0., 1., 1.],
| [1., 1., 1.]])
|
| spacing
| Return or set the spacing for each axial direction.
|
| Notes
| -----
| Spacing must be non-negative. While VTK accepts negative
| spacing, this results in unexpected behavior. See:
| https://github.com/pyvista/pyvista/issues/1967
|
| Examples
| --------
| Create a 5 x 5 x 5 uniform grid.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> grid.spacing
| (1.0, 1.0, 1.0)
| >>> grid.plot(show_edges=True)
|
| Modify the spacing to ``(1, 2, 3)``
|
| >>> grid.spacing = (1, 2, 3)
| >>> grid.plot(show_edges=True)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| ----------------------------------------------------------------------
| Methods inherited from Grid:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| to_hexahedra(self: 'Self') -> 'UnstructuredGrid'
| Convert voxels to hexahedra.
|
| Convert this mesh to :class:`~pyvista.UnstructuredGrid` with
| :attr:`~pyvista.CellType.HEXAHEDRON` cells. Equivalent to
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` except the output has
| hexahedra instead of :attr:`~pyvista.CellType.VOXEL` cells.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with :attr:`~pyvista.CellType.HEXAHEDRON` cells.
|
| Raises
| ------
| ValueError
| If the input is not 3-dimensional.
|
| See Also
| --------
| to_quads, to_tetrahedra
| pyvista.DataSet.cast_to_unstructured_grid
|
| Examples
| --------
| Convert a 3D :class:`~pyvista.ImageData` to hexahedra.
|
| >>> import pyvista as pv
| >>> image = pv.ImageData(dimensions=(2, 2, 2))
| >>> hexes = image.to_hexahedra()
| >>> hexes.distinct_cell_types == {pv.CellType.HEXAHEDRON}
| True
|
| to_quads(self: 'Self') -> 'UnstructuredGrid'
| Convert pixels to quads.
|
| Convert this mesh to :class:`~pyvista.UnstructuredGrid` with
| :attr:`~pyvista.CellType.QUAD` cells. Equivalent to
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` except the output has
| quads instead of :attr:`~pyvista.CellType.PIXEL` cells.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with :attr:`~pyvista.CellType.QUAD` cells.
|
| Raises
| ------
| ValueError
| If the input is not 2-dimensional.
|
| See Also
| --------
| to_hexahedra, to_tetrahedra
| pyvista.DataSet.cast_to_unstructured_grid
|
| Examples
| --------
| Convert a 2D :class:`~pyvista.ImageData` to quads.
|
| >>> import pyvista as pv
| >>> image = pv.ImageData(dimensions=(3, 2, 1))
| >>> quads = image.to_quads()
| >>> quads.distinct_cell_types == {pv.CellType.QUAD}
| True
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Grid:
|
| dimensions
| Return the grid's dimensions.
|
| These are effectively the number of points along each of the
| three dataset axes.
|
| Returns
| -------
| tuple[int]
| Dimensions of the grid.
|
| Examples
| --------
| Create a uniform grid with dimensions ``(1, 2, 3)``.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(2, 3, 4))
| >>> grid.dimensions
| (2, 3, 4)
| >>> grid.plot(show_edges=True)
|
| Set the dimensions to ``(3, 4, 5)``
|
| >>> grid.dimensions = (3, 4, 5)
| >>> grid.plot(show_edges=True)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.image_data.ImageDataFilters:
|
| cells_to_points(self: 'ImageData', scalars: 'str | None' = None, *, dimensionality: "VectorLike[bool] | Literal[0, 1, 2, 3, '0D', '1D', '2D', '3D', 'preserve']" = 'preserve', copy: 'bool' = True)
| Re-mesh image data from a cell-based to a point-based representation.
|
| This filter changes how image data is represented. Data represented as cells
| at the input is re-meshed into an alternative representation as points at the
| output. Only the :class:`~pyvista.ImageData` container is modified so that
| the number of input cells equals the number of output points. The re-meshing is
| otherwise lossless in the sense that cell data at the input is passed through
| unmodified and stored as point data at the output. Any point data at the input is
| ignored and is not used by this filter.
|
| To change the image data's representation, the input cell centers are used to
| represent the output points. This has the effect of "shrinking" the
| input image dimensions by one along each axis (i.e. half the cell width on each
| side). For example, an image with 101 points and 100 cells along an axis at the
| input will have 100 points and 99 cells at the output. If the input has 1mm
| spacing, the axis size will also decrease from 100mm to 99mm.
|
| Since filters may be inherently cell-based (e.g. some :class:`~pyvista.DataSetFilters`)
| or may operate on point data exclusively (e.g. most :class:`~pyvista.ImageDataFilters`),
| re-meshing enables the same data to be used with either kind of filter while
| ensuring the input data to those filters has the appropriate representation.
| This filter is also useful when plotting image data to achieve a desired visual
| effect, such as plotting images as points instead of as voxel cells.
|
| .. note::
| Only the input's :attr:`~pyvista.ImageData.dimensions`, and
| :attr:`~pyvista.ImageData.origin` are modified by this filter. Other spatial
| properties such as :attr:`~pyvista.ImageData.spacing` and
| :attr:`~pyvista.ImageData.direction_matrix` are not affected.
|
| .. versionadded:: 0.44.0
|
| See Also
| --------
| points_to_cells
| Inverse of this filter to represent points as cells.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample cell data as point data without modifying the container.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample point data as cell data without modifying the container.
|
| Parameters
| ----------
| scalars : str, optional
| Name of cell data scalars to pass through to the output as point data. Use
| this parameter to restrict the output to only include the specified array.
| By default, all cell data arrays at the input are passed through as point
| data at the output.
|
| dimensionality : VectorLike[bool], Literal[0, 1, 2, 3, "0D", "1D", "2D", "3D", "preserve"]
| Control which dimensions will be modified by the filter.
| ``'preserve'`` is used by default.
|
| - Can be specified as a sequence of 3 boolean to allow modification on a per
| dimension basis.
| - ``0`` or ``'0D'``: convenience alias to output a 0D ImageData with
| dimensions ``(1, 1, 1)``. Only valid for 0D inputs.
| - ``1`` or ``'1D'``: convenience alias to output a 1D ImageData where
| exactly one dimension is greater than one, e.g. ``(>1, 1, 1)``. Only valid
| for 0D or 1D inputs.
| - ``2`` or ``'2D'``: convenience alias to output a 2D ImageData where
| exactly two dimensions are greater than one, e.g. ``(>1, >1, 1)``. Only
| valid for 0D, 1D, or 2D inputs.
| - ``3`` or ``'3D'``: convenience alias to output a 3D ImageData, where all
| three dimensions are greater than one, e.g. ``(>1, >1, >1)``. Valid for
| any 0D, 1D, 2D, or 3D inputs.
| - ``'preserve'`` (default): convenience alias to not modify singleton
| dimensions.
|
| .. note::
| This filter does not modify singleton dimensions with ``dimensionality``
| set as ``'preserve'`` by default.
|
| copy : bool, default: True
| Copy the input cell data before associating it with the output point data.
| If ``False``, the input and output will both refer to the same data array(s).
|
| Returns
| -------
| pyvista.ImageData
| Image with a point-based representation.
|
| Examples
| --------
| Load an image with cell data.
|
| >>> from pyvista import examples
| >>> image = examples.load_uniform()
|
| Show the current properties and cell arrays of the image.
|
| >>> image
| ImageData (...)
| N Cells: 729
| N Points: 1000
| X Bounds: 0.000e+00, 9.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| Dimensions: 10, 10, 10
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 2
|
| >>> image.cell_data.keys()
| ['Spatial Cell Data']
|
| Re-mesh the cells and cell data as points and point data.
|
| >>> points_image = image.cells_to_points()
|
| Show the properties and point arrays of the re-meshed image.
|
| >>> points_image
| ImageData (...)
| N Cells: 512
| N Points: 729
| X Bounds: 5.000e-01, 8.500e+00
| Y Bounds: 5.000e-01, 8.500e+00
| Z Bounds: 5.000e-01, 8.500e+00
| Dimensions: 9, 9, 9
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> points_image.point_data.keys()
| ['Spatial Cell Data']
|
| Observe that:
|
| - The input cell array is now a point array
| - The output has one less array (the input point data is ignored)
| - The dimensions have decreased by one
| - The bounds have decreased by half the spacing
| - The output ``N Points`` equals the input ``N Cells``
|
| See :ref:`image_representations_example` for more examples using this filter.
|
| close(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Perform morphological closing on continuous or binary data.
|
| Closing is a :meth:`dilation <dilate>` followed by an :meth:`erosion <erode>`.
| It is used to fill small holes/gaps while preserving the shape and size of larger objects.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are closed, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary closing or continuous closing is used. Refer to
| :meth:`dilate` and/or :meth:`erode` for details about using this keyword.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been closed.
|
| See Also
| --------
| open, erode, dilate
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| Load a binary image: :func:`~pyvista.examples.downloads.download_yinyang()`.
|
| >>> from pyvista import examples
| >>> im = examples.download_yinyang()
|
| Use ``close`` with a relatively small kernel to fill the top black edge of the yinyang.
|
| >>> closed = im.close(kernel_size=5)
| >>> kwargs = dict(
| ... cmap='grey',
| ... lighting=False,
| ... cpos='xy',
| ... zoom='tight',
| ... show_axes=False,
| ... show_scalar_bar=False,
| ... )
| >>> closed.plot(**kwargs)
|
| Use a much larger kernel to also fill the small black circle.
|
| >>> closed = im.close(kernel_size=25)
| >>> closed.plot(**kwargs)
|
| Since closing is the inverse of opening, we can alternatively use :meth:`open` to
| fill the white foreground values instead of the black background.
|
| >>> opened = im.open(kernel_size=25)
| >>> opened.plot(**kwargs)
|
| concatenate(self: 'ImageData', images: 'ImageData | Sequence[ImageData]', axis: '_AxisOptions | None' = None, *, mode: '_ConcatenateModeOptions | None' = None, dtype_policy: '_ConcatenateDTypePolicyOptions | None' = None, component_policy: '_ConcatenateComponentPolicyOptions | None' = None, background_value: 'float | VectorLike[float]' = 0.0, resample_kwargs: 'dict[str, Any] | None' = None)
| Combine multiple images into one.
|
| This filter uses :vtk:`vtkImageAppend` to combine multiple images. By default, images are
| concatenated along the specified ``axis``, and all images must have:
|
| #. identical dimensions except along the specified ``axis``,
| #. the same scalar dtype, and
| #. the same number of scalar components.
|
| Use ``mode`` for cases with mismatched dimensions, ``dtype_policy`` for cases with
| mismatched dtypes, and/or ``component_policy`` for cases with mismatched scalar components.
|
| The output has the same :attr:`~pyvista.ImageData.origin` and
| :attr:`~pyvista.ImageData.spacing` as the first input. The origin and spacing of all other
| inputs are ignored.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| images : ImageData | Sequence[ImageData]
| The input image(s) to concatenate. The default active scalars are used for all images.
|
| axis : int | str, default: 'x'
| Axis along which the images are concatenated:
|
| - ``0`` or ``'x'``: x-axis
| - ``1`` or ``'y'``: y-axis
| - ``2`` or ``'z'``: z-axis
|
| mode : str, default: 'strict'
| Concatenation mode to use. This determines how images are placed in the output. All
| modes operate along the specified ``axis`` except for ``'preserve-extents'``.
| Specify one of:
|
| - ``'strict'``: all images must have identical dimensions except along the specified
| ``axis``.
| - ``'resample-off-axis'``: :meth:`resample` off-axis dimensions of concatenated images
| to match the input. The on-axis dimension is `not` resampled.
| - ``'resample-match'``: :meth:`resample` all dimensions of concatenated images
| to match the input dimensions exactly. This is similar to ``'resample-off-axis'``,
| except the on-axis dimension is `also` resampled.
| - ``'resample-proportional'``: :meth:`resample` concatenated images proportionally to
| preserve their aspect ratio(s).
| - ``'crop-off-axis'``: :meth:`crop` off-axis dimensions of concatenated images
| to match the input. The on-axis dimension is `not` cropped.
| - ``'crop-match'``: Use :meth:`crop` to center-crop concatenated images such that
| their dimensions match the input dimensions exactly. This is similar to
| ``'crop-off-axis'``, except the on-axis dimension is `also` cropped.
| - ``'preserve-extents'``: the extents of all images are preserved and used to place the
| images in the output. The whole extent of the output is the union of the input whole
| extents. The origin and spacing is taken from the first input. ``axis`` is not used
| by this mode.
|
| .. note::
| Images may be padded with ``background_value`` in some cases when there are
| mismatched dimensions.
|
| dtype_policy : 'strict' | 'promote' | 'match', default: 'strict'
| - ``'strict'``: Do not cast any scalar array dtypes. All images being concatenated must
| have the same dtype, else a ``TypeError`` is raised.
| - ``'promote'``: Use :func:`numpy.result_type` to compute the dtype of the output
| image scalars. This option safely casts all input arrays to a common dtype before
| concatenating.
| - ``'match'``: Cast all array dtypes to match the input's dtype. This casting is
| unsafe as it may downcast values and lose precision.
|
| component_policy : 'strict' | 'promote_rgba', default: 'strict'
| - ``'strict'``: Do not modify the number of components of any scalars. All images being
| concatenated must have the same number of components, else a ``ValueError`` is
| raised.
| - ``'promote_rgba'``: Increase the number of components if necessary. Grayscale scalars
| with one component may be promoted to RGB scalars by duplicating values,
| and RGB scalars may be promoted to RGBA scalars by including an opacity component.
| For integer dtypes, the opacity is set to the max int representable by the dtype;
| for floats it is set to ``1.0``.
|
| background_value : float | VectorLike[float], default: 0
| Value or multi-component vector to use as background. The output may be padded with
| this value for some ``modes`` when there are mismatched dimensions.
|
| resample_kwargs : dict, optional
| Keyword arguments passed to :meth:`resample` when using ``'resample-off-axis'`` or
| ``'resample-proportional'`` modes. Specify ``interpolation``, ``border_mode`` or
| ``anti_aliasing`` options.
|
| Returns
| -------
| ImageData
| The concatenated image.
|
| Examples
| --------
| .. pyvista-plot::
| :force_static:
|
| Load a 2D image: :func:`~pyvista.examples.downloads.download_beach`.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beach = examples.download_beach()
|
| Use :meth:`select_values` to make a second version with white values converted to black
| to distinguish it from the original.
|
| >>> white = [255, 255, 255]
| >>> black = [0, 0, 0]
| >>> beach_black = beach.select_values(white, fill_value=black, invert=True)
|
| Concatenate them along the x-axis.
|
| >>> concatenated = beach.concatenate(beach_black, axis='x')
| >>> plot_kwargs = dict(
| ... rgb=True,
| ... lighting=False,
| ... cpos='xy',
| ... zoom='tight',
| ... show_axes=False,
| ... show_scalar_bar=False,
| ... )
| >>> concatenated.plot(**plot_kwargs)
|
| Concatenate them along the y-axis.
|
| >>> concatenated = beach.concatenate(beach_black, axis='y')
| >>> concatenated.plot(**plot_kwargs)
|
| By default, concatenation requires that all off-axis dimensions match the input. Use
| the ``mode`` keyword to enable concatenation with mismatched dimensions.
|
| Load a second 2D image with different dimensions:
| :func:`~pyvista.examples.downloads.download_bird`.
|
| >>> bird = examples.download_bird()
| >>> bird.dimensions
| (458, 342, 1)
| >>> beach.dimensions
| (100, 100, 1)
|
| Concatenate using ``'resample-proportional'`` mode to preserve the aspect ratio of the
| concatenated image. Linear interpolation with antialiasing is used to avoid sampling
| artifacts.
|
| >>> resample_kwargs = {'interpolation': 'linear', 'anti_aliasing': True}
| >>> concatenated = beach.concatenate(
| ... bird, mode='resample-proportional', resample_kwargs=resample_kwargs
| ... )
| >>> concatenated.dimensions
| (233, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'resample-proportional'`` again but concontenate along the z-axis instead. The
| ``bird``'s aspect ratio is preserved and padded with zeros so that it can be stacked
| on top of ``beach``.
|
| >>> concatenated = beach.concatenate(
| ... bird,
| ... axis='z',
| ... mode='resample-proportional',
| ... resample_kwargs=resample_kwargs,
| ... )
| >>> concatenated.dimensions
| (100, 100, 2)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'resample-off-axis'`` to only resample off-axis dimensions. This option may
| distort the image.
|
| >>> concatenated = beach.concatenate(
| ... bird, mode='resample-off-axis', resample_kwargs=resample_kwargs
| ... )
| >>> concatenated.dimensions
| (558, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'resample-match'`` to resample all dimensions to match the input exactly. This
| option may also distort the image.
|
| >>> concatenated = beach.concatenate(
| ... bird, mode='resample-match', resample_kwargs=resample_kwargs
| ... )
| >>> concatenated.dimensions
| (200, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use the ``'preserve-extents'`` mode. Using this mode naively may not produce the
| desired result, e.g. if we concatenate ``beach`` with ``bird``, the ``beach`` image is
| completely overwritten since their :attr:`~pyvista.ImageData.extent` fully overlap.
|
| >>> beach.extent
| (0, 99, 0, 99, 0, 0)
| >>> bird.extent
| (0, 457, 0, 341, 0, 0)
|
| >>> concatenated = beach.concatenate(bird, mode='preserve-extents')
| >>> concatenated.extent
| (0, 457, 0, 341, 0, 0)
| >>> concatenated.plot(**plot_kwargs)
|
| Set the ``beach`` :attr:`~pyvista.ImageData.offset` so that there is only partial
| overlap instead.
|
| >>> beach.offset = (-50, -50, 0)
| >>> beach.extent
| (-50, 49, -50, 49, 0, 0)
|
| >>> concatenated = beach.concatenate(bird, mode='preserve-extents')
| >>> concatenated.extent
| (-50, 457, -50, 341, 0, 0)
| >>> concatenated.plot(**plot_kwargs)
|
| Reverse the concatenation order, and use a green background value.
|
| >>> green = pv.Color('green').int_rgb
| >>> concatenated = bird.concatenate(
| ... beach, mode='preserve-extents', background_value=green
| ... )
| >>> concatenated.extent
| (-50, 457, -50, 341, 0, 0)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'crop-off-axis'`` to only crop off-axis dimensions.
|
| >>> concatenated = beach.concatenate(bird, mode='crop-off-axis')
| >>> concatenated.dimensions
| (558, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Reverse the concatenation order.
|
| >>> concatenated = bird.concatenate(beach, mode='crop-off-axis')
| >>> concatenated.dimensions
| (558, 342, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'crop-match'`` to center-crop the images to match the input's
| dimensions.
|
| >>> concatenated = beach.concatenate(bird, mode='crop-match')
| >>> concatenated.dimensions
| (200, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Reverse the concatenation order, and use a grey background value.
|
| >>> concatenated = bird.concatenate(
| ... beach, mode='crop-match', background_value=128
| ... )
| >>> concatenated.dimensions
| (558, 342, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Load a binary image: :func:`~pyvista.examples.downloads.download_yinyang()`.
|
| >>> yinyang = examples.download_yinyang()
|
| Use ``component_policy`` to concatenate grayscale images with RGB(A) images.
|
| >>> concatenated = yinyang.concatenate(
| ... beach, mode='resample-proportional', component_policy='promote_rgba'
| ... )
| >>> concatenated.plot(**plot_kwargs)
|
| The grayscale portion of the image is promoted to RGB in this case and the entire
| image has 3 components:
|
| >>> concatenated.active_scalars.shape
| (292068, 3)
|
| contour_labeled(self, n_labels: 'int | None' = None, smoothing: 'bool' = False, smoothing_num_iterations: 'int' = 50, smoothing_relaxation_factor: 'float' = 0.5, smoothing_constraint_distance: 'float' = 1, output_mesh_type: "Literal['quads', 'triangles']" = 'quads', output_style: "Literal['default', 'boundary']" = 'default', scalars: 'str | None' = None, progress_bar: 'bool' = False) -> 'pv.PolyData'
| Generate labeled contours from 3D label maps.
|
| SurfaceNets algorithm is used to extract contours preserving sharp
| boundaries for the selected labels from the label maps.
| Optionally, the boundaries can be smoothened to reduce the staircase
| appearance in case of low resolution input label maps.
|
| This filter requires that the :class:`ImageData` has integer point
| scalars, such as multi-label maps generated from image segmentation.
|
| .. note::
| Requires ``vtk>=9.3.0``.
|
| .. deprecated:: 0.45
| This filter produces unexpected results and is deprecated.
| Use :meth:`~pyvista.ImageDataFilters.contour_labels` instead.
| See https://github.com/pyvista/pyvista/issues/5981 for details.
|
| To replicate the default behavior from this filter, call `contour_labels`
| with the following arguments:
|
| .. code-block:: python
|
| image.contour_labels(
| boundary_style='strict_external', # old filter strictly uses external polygons
| smoothing=False, # old filter does not apply smoothing
| output_mesh_type='quads', # old filter generates quads
| pad_background=False, # old filter generates open surfaces at input edges
| orient_faces=False, # old filter does not orient faces
| simplify_output=False, # old filter returns multi-component scalars
| )
|
| Parameters
| ----------
| n_labels : int, optional
| Number of labels to be extracted (all are extracted if None is given).
|
| smoothing : bool, default: False
| Apply smoothing to the meshes.
|
| smoothing_num_iterations : int, default: 50
| Number of smoothing iterations.
|
| smoothing_relaxation_factor : float, default: 0.5
| Relaxation factor of the smoothing.
|
| smoothing_constraint_distance : float, default: 1
| Constraint distance of the smoothing.
|
| output_mesh_type : str, default: 'quads'
| Type of the output mesh. Must be either ``'quads'``, or ``'triangles'``.
|
| output_style : str, default: 'default'
| Style of the output mesh. Must be either ``'default'`` or ``'boundary'``.
| When ``'default'`` is specified, the filter produces a mesh with both
| interior and exterior polygons. When ``'boundary'`` is selected, only
| polygons on the border with the background are produced (without interior
| polygons). Note that style ``'selected'`` is currently not implemented.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| :class:`pyvista.PolyData` Labeled mesh with the segments labeled.
|
| References
| ----------
| Sarah F. Frisken, SurfaceNets for Multi-Label Segmentations with Preservation
| of Sharp Boundaries, Journal of Computer Graphics Techniques (JCGT), vol. 11,
| no. 1, 34-54, 2022. Available online http://jcgt.org/published/0011/01/03/
|
| https://www.kitware.com/really-fast-isocontouring/
|
| Examples
| --------
| See :ref:`contouring_example` for a full example using this filter.
|
| See Also
| --------
| pyvista.DataSetFilters.contour
| Generalized contouring method which uses MarchingCubes or FlyingEdges.
|
| pyvista.DataSetFilters.pack_labels
| Function used internally by SurfaceNets to generate contiguous label data.
|
| contour_labels(self: 'ImageData', boundary_style: "Literal['external', 'internal', 'all', 'strict_external']" = 'external', *, background_value: 'int' = 0, select_inputs: 'int | VectorLike[int] | None' = None, select_outputs: 'int | VectorLike[int] | None' = None, pad_background: 'bool' = True, output_mesh_type: "Literal['quads', 'triangles'] | None" = None, scalars: 'str | None' = None, orient_faces: 'bool | None' = None, simplify_output: 'bool | None' = None, smoothing: 'bool' = True, smoothing_iterations: 'int' = 16, smoothing_relaxation: 'float' = 0.5, smoothing_distance: 'float | None' = None, smoothing_scale: 'float' = 1.0, progress_bar: 'bool' = False) -> 'PolyData'
| Generate surface contours from 3D image label maps.
|
| This filter uses :vtk:`vtkSurfaceNets3D`
| to extract polygonal surface contours from non-continuous label maps, which
| corresponds to discrete regions in an input 3D image (i.e., volume). It is
| designed to generate surfaces from image point data, e.g. voxel point
| samples from 3D medical images, though images with cell data are also supported.
|
| The generated surface is smoothed using a constrained smoothing filter, which
| may be fine-tuned to control the smoothing process. Optionally, smoothing may
| be disabled to generate a staircase-like surface.
|
| The output surface includes a two-component cell data array ``'boundary_labels'``.
| The array indicates the labels/regions on either side of the polygons composing
| the output. The array's values are structured as follows:
|
| External boundary values
|
| Polygons between a foreground region and the background have the
| form ``[foreground, background]``.
|
| E.g. ``[1, 0]`` for the boundary between region ``1`` and background ``0``.
|
| Internal boundary values
|
| Polygons between two connected foreground regions are sorted in ascending order.
|
| E.g. ``[1, 2]`` for the boundary between regions ``1`` and ``2``.
|
| By default, this filter returns ``'external'`` contours only. Optionally,
| only the ``'internal'`` contours or ``'all'`` contours (i.e. internal and
| external) may be returned.
|
| .. note::
|
| This filter requires VTK version ``9.3.0`` or greater.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| boundary_style : 'external' | 'internal' | 'all' | 'strict_external', default: 'external'
| Style of boundary polygons to generate. ``'internal'`` polygons are generated
| between two connected foreground regions. ``'external'`` polygons are
| generated between foreground and background regions. ``'all'`` includes
| both internal and external boundary polygons.
|
| These styles are generated such that ``internal + external = all``.
| Internally, the filter computes all boundary polygons by default and
| then removes any undesired polygons in post-processing.
| This improves the quality of the output, but can negatively affect the
| filter's performance since all boundaries are always initially computed.
|
| The ``'strict_external'`` style can be used as a fast alternative to
| ``'external'``. This style `strictly` generates external polygons and does
| not compute or consider internal boundaries. This computation is fast, but
| also results in jagged, non-smooth boundaries between regions. The
| ``select_inputs`` and ``select_outputs`` options cannot be used with this
| style.
|
| background_value : int, default: 0
| Background value of the input image. All other values are considered
| as foreground.
|
| select_inputs : int | VectorLike[int], default: None
| Specify label ids to include as inputs to the filter. Labels that are not
| selected are removed from the input *before* generating the surface. By
| default, all label ids are used.
|
| Since the smoothing operation occurs across selected input regions, using
| this option to filter the input can result in smoother and more visually
| pleasing surfaces since non-selected inputs are not considered during
| smoothing. However, this also means that the generated surface will change
| shape depending on which inputs are selected.
|
| .. note::
|
| Selecting inputs can affect whether a boundary polygon is considered to
| be ``internal`` or ``external``. That is, an internal boundary becomes an
| external boundary when only one of the two foreground regions on the
| boundary is selected.
|
| select_outputs : int | VectorLike[int], default: None
| Specify label ids to include in the output of the filter. Labels that are
| not selected are removed from the output *after* generating the surface. By
| default, all label ids are used.
|
| Since the smoothing operation occurs across all input regions, using this
| option to filter the output means that the selected output regions will have
| the same shape (i.e. smoothed in the same manner), regardless of the outputs
| that are selected. This is useful for generating a surface for specific
| labels while also preserving sharp boundaries with non-selected outputs.
|
| .. note::
|
| Selecting outputs does not affect whether a boundary polygon is
| considered to be ``internal`` or ``external``. That is, an internal
| boundary remains internal even if only one of the two foreground regions
| on the boundary is selected.
|
| pad_background : bool, default: True
| :meth:`Pad <pyvista.ImageDataFilters.pad_image>` the image
| with ``background_value`` prior to contouring. This will
| generate polygons to "close" the surface at the boundaries of the image.
| This option is only relevant when there are foreground regions on the border
| of the image. Setting this value to ``False`` is useful if processing multiple
| volumes separately so that the generated surfaces fit together without
| creating surface overlap.
|
| output_mesh_type : str, default: None
| Type of the output mesh. Can be either ``'quads'``, or ``'triangles'``. By
| default, the output mesh has :attr:`~pyvista.CellType.TRIANGLE` cells when
| ``smoothing`` is enabled and :attr:`~pyvista.CellType.QUAD` cells (quads)
| otherwise. The mesh type can be forced to be triangles or quads; however,
| if smoothing is enabled and the type is ``'quads'``, the generated quads
| may not be planar.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars. If cell
| scalars are specified, the input image is first re-meshed with
| :meth:`~pyvista.ImageDataFilters.cells_to_points` to transform the cell
| data into point data.
|
| orient_faces : bool, optional
| .. deprecated:: 0.47
|
| This keyword should not be used and will be removed in a future version. It was
| meant to address a vtk bug where the faces generated by :vtk:`vtkSurfaceNets3D`
| have incorrect orientation. This bug is fixed in VTK 9.6, and therefore the faces
| now always have correct orientation by default.
|
| Orient the faces of the generated contours so that they have consistent
| ordering and face outward. If ``False``, the generated polygons may have
| inconsistent ordering and orientation, which can negatively impact
| downstream calculations and the shading used for rendering.
|
| .. note::
|
| Orienting the faces can be computationally expensive for large meshes.
| Consider disabling this option to improve this filter's performance.
|
| .. warning::
|
| Enabling this option is `likely` to generate surfaces with normals
| pointing outward when ``pad_background`` is ``True`` and
| ``boundary_style`` is ``'external'`` (the default). However, this is
| not guaranteed if the generated surface is not closed or if internal
| boundaries are generated. Do not assume the normals will point outward
| in all cases.
|
| simplify_output : bool, optional
| Simplify the ``'boundary_labels'`` array as a single-component 1D array.
| If ``False``, the returned ``'boundary_labels'`` array is a two-component
| 2D array. This simplification is useful when only external boundaries
| are generated and/or when visualizing internal boundaries. The
| simplification is as follows:
|
| - External boundaries are simplified by keeping the first component and
| removing the second. Since external polygons may only share a boundary
| with the background, the second component is always ``background_value``
| and therefore can be dropped without loss of information. The values
| of external boundaries always match the foreground values of the input.
|
| - Internal boundaries are simplified by assigning them unique negative
| values sequentially. E.g. the boundary label ``[1, 2]`` is replaced with
| ``-1``, ``[1, 3]`` is replaced with ``-2``, etc. The mapping to negative
| values is not fixed, and can change depending on the input.
|
| This simplification is particularly useful for unsigned integer labels
| (e.g. scalars with ``'uint8'`` dtype) since external boundaries
| will be positive and internal boundaries will be negative in this case.
|
| By default, the output is simplified when ``boundary_type`` is
| ``'external'`` or ``'strict_external'``, and is not simplified otherwise.
|
| smoothing : bool, default: True
| Smooth the generated surface using a constrained smoothing filter. Each
| point in the surface is smoothed as follows:
|
| For a point ``pi`` connected to a list of points ``pj`` via an edge, ``pi``
| is moved towards the average position of ``pj`` multiplied by the
| ``smoothing_relaxation`` factor, and limited by the ``smoothing_distance``
| constraint. This process is repeated either until convergence occurs, or
| the maximum number of ``smoothing_iterations`` is reached.
|
| smoothing_iterations : int, default: 16
| Maximum number of smoothing iterations to use.
|
| smoothing_relaxation : float, default: 0.5
| Relaxation factor used at each smoothing iteration.
|
| smoothing_distance : float, default: None
| Maximum distance each point is allowed to move (in any direction) during
| smoothing. This distance may be scaled with ``smoothing_scale``. By default,
| the distance is computed dynamically from the image spacing as:
|
| ``distance = norm(image_spacing) * smoothing_scale``.
|
| smoothing_scale : float, default: 1.0
| Relative scaling factor applied to ``smoothing_distance``. See that
| parameter for details.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of labeled regions.
|
| See Also
| --------
| :meth:`~pyvista.DataSetFilters.voxelize_binary_mask`
| Filter that generates binary labeled :class:`~pyvista.ImageData` from
| :class:`~pyvista.PolyData` surface contours. Can beloosely considered as
| an inverse of this filter.
|
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter which can used to process the multi-component
| scalars generated by this filter.
|
| :meth:`~pyvista.DataSetFilters.contour`
| Generalized contouring method which uses MarchingCubes or FlyingEdges.
|
| :meth:`~pyvista.DataSetFilters.pack_labels`
| Function used internally by SurfaceNets to generate contiguous label data.
|
| :meth:`~pyvista.DataSetFilters.color_labels`
| Color labeled data, e.g. labeled volumes or contours.
|
| :ref:`contouring_example`, :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| References
| ----------
| S. Frisken, SurfaceNets for Multi-Label Segmentations with Preservation of
| Sharp Boundaries, J. Computer Graphics Techniques, 2022. Available online:
| http://jcgt.org/published/0011/01/03/
|
| W. Schroeder, S. Tsalikis, M. Halle, S. Frisken. A High-Performance SurfaceNets
| Discrete Isocontouring Algorithm. arXiv:2401.14906. 2024. Available online:
| `http://arxiv.org/abs/2401.14906 <http://arxiv.org/abs/2401.14906>`__
|
| Examples
| --------
| Load labeled image data with a background region ``0`` and four foreground
| regions.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> label_ids = np.unique(image.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
| >>> image.dimensions
| (251, 251, 101)
|
| Crop the image to simplify the data.
|
| >>> image = image.extract_subset(voi=(75, 109, 75, 109, 85, 100))
| >>> image.dimensions
| (35, 35, 16)
|
| Plot the cropped image for context. Use :meth:`~pyvista.DataSetFilters.color_labels`
| to generate consistent coloring of the regions for all plots. Negative indexing
| is used for plotting internal boundaries.
|
| >>> def labels_plotter(mesh, zoom=None):
| ... colored_mesh = mesh.color_labels(negative_indexing=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored_mesh, show_edges=True)
| ... if zoom:
| ... pl.camera.zoom(zoom)
| ... return pl
| >>>
| >>> labels_plotter(image).show()
|
| Generate surface contours of the foreground regions and plot it. Note that
| the ``background_value`` is ``0`` by default.
|
| >>> contours = image.contour_labels()
| >>> labels_plotter(contours, zoom=1.5).show()
|
| By default, only external boundary polygons are generated and the returned
| ``'boundary_labels'`` array is a single-component array. The output values
| match the input label values.
|
| >>> contours['boundary_labels'].ndim
| 1
| >>> np.unique(contours['boundary_labels'])
| pyvista_ndarray([1, 2, 3, 4])
|
| Set ``simplify_output`` to ``False`` to generate a two-component
| array instead showing the two boundary regions associated with each polygon.
|
| >>> contours = image.contour_labels(simplify_output=False)
| >>> contours['boundary_labels'].ndim
| 2
|
| Show the unique values. Since only ``'external'`` boundaries are generated
| by default, the second component is always ``0`` (i.e. the ``background_value``).
| Note that all four foreground regions share a boundary with the background.
|
| >>> np.unique(contours['boundary_labels'], axis=0)
| array([[1, 0],
| [2, 0],
| [3, 0],
| [4, 0]])
|
| Repeat the example but this time generate internal contours only. The generated
| array is 2D by default.
|
| >>> contours = image.contour_labels('internal')
| >>> contours['boundary_labels'].ndim
| 2
|
| Show the unique two-component boundary labels again. From these values we can
| determine that all foreground regions share an internal boundary with each
| other `except` for regions ``1`` and ``3`` since the boundary value ``[1, 3]``
| is missing.
|
| >>> np.unique(contours['boundary_labels'], axis=0)
| array([[1, 2],
| [1, 4],
| [2, 3],
| [2, 4],
| [3, 4]])
|
| Simplify the output so that each internal multi-component boundary value is
| assigned a unique negative integer value instead. This makes it easier to
| visualize the result with :meth:`~pyvista.DataSetFilters.color_labels` using
| the ``negative_indexing`` option.
|
| >>> contours = image.contour_labels('internal', simplify_output=True)
| >>> contours['boundary_labels'].ndim
| 1
| >>> np.unique(contours['boundary_labels'])
| pyvista_ndarray([-5, -4, -3, -2, -1])
|
| >>> labels_plotter(contours, zoom=1.5).show()
|
| Generate contours for all boundaries, and use ``select_outputs`` to filter
| the output to only include polygons which share a boundary with region ``3``.
|
| >>> region_3 = image.contour_labels(
| ... 'all', select_outputs=3, simplify_output=True
| ... )
| >>> labels_plotter(region_3, zoom=3).show()
|
| Note how using ``select_outputs`` preserves the sharp features and boundary
| labels for non-selected regions. If desired, use ``select_inputs`` instead to
| completely "ignore" non-selected regions.
|
| >>> region_3 = image.contour_labels(select_inputs=3)
| >>> labels_plotter(region_3, zoom=3).show()
|
| The sharp features are now smoothed and the internal boundaries are now labeled
| as external boundaries. Note that using ``'all'`` here is optional since
| using ``select_inputs`` converts previously-internal boundaries into external
| ones.
|
| Do not pad the image with background values before contouring. Since the input image
| has foreground regions visible at the edges of the image (e.g. the ``+Z`` bound),
| setting ``pad_background=False`` in this example causes the top and sides of
| the mesh to be "open".
|
| >>> surf = image.contour_labels(pad_background=False)
| >>> labels_plotter(surf, zoom=1.5).show()
|
| Disable smoothing to generate staircase-like surface. Without smoothing, the
| surface has quadrilateral cells by default.
|
| >>> surf = image.contour_labels(smoothing=False)
| >>> labels_plotter(surf, zoom=1.5).show()
|
| Keep smoothing enabled but reduce the smoothing scale. A smoothing scale
| less than one may help preserve sharp features (e.g. corners).
|
| >>> surf = image.contour_labels(smoothing_scale=0.5)
| >>> labels_plotter(surf, zoom=1.5).show()
|
| Use the ``'strict_external'`` style to compute external contours quickly. Note
| that this produces jagged and non-smooth boundaries between regions, which may
| not be desirable. Also note how the top of the surface is perfectly flat compared
| to the default ``'external'`` style (see first example above) since the strict
| style ignores the smoothing effects of all internal boundaries.
|
| >>> surf = image.contour_labels('strict_external')
| >>> labels_plotter(surf, zoom=1.5).show()
|
| crop(self: 'ImageData', *, factor: 'float | VectorLike[float] | None' = None, margin: 'int | VectorLike[int] | None' = None, offset: 'VectorLike[int] | None' = None, dimensions: 'VectorLike[int] | None' = None, extent: 'VectorLike[int] | None' = None, normalized_bounds: 'VectorLike[float] | None' = None, mask: 'str | ImageData | NumpyArray[float] | Literal[True] | None' = None, padding: 'int | VectorLike[int] | None' = None, background_value: 'float | None' = None, keep_dimensions: 'bool' = False, fill_value: 'float | VectorLike[float] | None' = None, rebase_coordinates: 'bool' = False, progress_bar: 'bool' = False) -> 'ImageData'
| Crop this image to remove points at its boundaries.
|
| This filter is useful for extracting a volume or region of interest. There are several ways
| to crop:
|
| #. Use ``factor`` to crop a portion of the image symmetrically.
| #. Use ``margin`` to remove points from the image border.
| #. Use ``dimensions`` (and optionally, ``offset``) to explicitly crop to the specified
| :attr:`~pyvista.ImageData.dimensions` and :attr:`~pyvista.ImageData.offset`.
| #. Use ``extent`` to explicitly crop to a specified :attr:`~pyvista.ImageData.extent`.
| #. Use ``normalized_bounds`` to crop a bounding box relative to the input size.
| #. Use ``mask``, ``padding``, and ``background_value`` to crop to this mesh using scalar
| values to define the cropping region.
|
| These methods are all independent, e.g. it is not possible to specify both ``factor`` and
| ``margin``.
|
| By default, the cropped output's :attr:`~pyvista.ImageData.dimensions` are typically less
| than the input's dimensions. Optionally, use ``keep_dimensions`` and ``fill_value`` to
| ensure the output dimensions always match the input.
|
| .. note::
|
| All cropping is performed using the image's ijk-indices, not physical xyz-bounds.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| factor : float, optional
| Cropping factor in range ``[0.0, 1.0]`` which specifies the proportion of the image to
| keep along each axis. Use a single float for uniform cropping or a vector of three
| floats for cropping each xyz-axis independently. The crop is centered in the image.
|
| margin : int | VectorLike[int], optional
| Margin to remove from each side of each axis. Specify:
|
| - A single value to remove from all boundaries equally.
| - Two values, one for each ``(X, Y)`` axis, to remove margin from
| each axis independently.
| - Three values, one for each ``(X, Y, Z)`` axis, to remove margin from
| each axis independently.
| - Four values, one for each ``(-X, +X, -Y, +Y)`` boundary, to remove
| margin from each boundary independently.
| - Six values, one for each ``(-X, +X, -Y, +Y, -Z, +Z)`` boundary, to remove
| margin from each boundary independently.
|
| offset : VectorLike[int], optional
| Length-3 vector of integers specifying the :attr:`~pyvista.ImageData.offset` indices
| where the cropping region originates. If specified, then ``dimensions`` must also be
| provided.
|
| dimensions : VectorLike[int], optional
| Length-3 vector of integers specifying the :attr:`~pyvista.ImageData.dimensions` of
| the cropping region. ``offset`` may also be provided, but if it is not, the crop is
| centered in the image.
|
| extent : VectorLike[int], optional
| Length-6 vector of integers specifying the full :attr:`~pyvista.ImageData.extent` of
| the cropping region.
|
| normalized_bounds : VectorLike[float], optional
| Normalized bounds relative to the input. These are floats between ``0.0`` and ``1.0``
| that define a box relative to the input size. The input is cropped such that it fully
| fits within these bounds. Has the form ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| mask : str | ImageData | NumpyArray[float] | bool, optional
| Scalar values that define the cropping region. Set this option to:
|
| - a string denoting the name of scalars belonging to this mesh
| - ``True`` to use this mesh's default scalars
| - a separate image, in which case the other image's active scalars are used
| - a 1D or 2D (multi-component) array
|
| The length of the scalar array must equal the number of points.
|
| This mesh will be cropped to the bounds of the foreground values of the array, i.e.
| values that are not equal to the specified ``background_value``.
|
| padding : int | VectorLike[int], optional
| Padding to add to foreground region `before` cropping. Only valid when using a mask to
| crop the image. Specify:
|
| - A single value to pad all boundaries equally.
| - Two values, one for each ``(X, Y)`` axis, to apply symmetric padding to
| each axis independently.
| - Three values, one for each ``(X, Y, Z)`` axis, to apply symmetric padding
| to each axis independently.
| - Four values, one for each ``(-X, +X, -Y, +Y)`` boundary, to apply
| padding to each boundary independently.
| - Six values, one for each ``(-X, +X, -Y, +Y, -Z, +Z)`` boundary, to apply
| padding to each boundary independently.
|
| The specified value is the `maximum` padding that may be applied. If the padding
| extends beyond the actual extents of this mesh, it is clipped and does not extend
| outside the bounds of the image.
|
| background_value : float | VectorLike[float], optional
| Value or multi-component vector considered to be the background. Only valid when using
| a mask to crop the image.
|
| keep_dimensions : bool, default: False
| If ``True``, the cropped output is :meth:`padded <pad_image>` with ``fill_value`` to
| ensure the output dimensions match the input.
|
| fill_value : float | VectorLike[float], optional
| Value used when padding the cropped output if ``keep_dimensions`` is ``True``. May be
| a single float or a multi-component vector (e.g. RGB vector).
|
| rebase_coordinates : bool, default: False
| Rebase the coordinate reference of the cropped output:
|
| - the :attr:`~pyvista.ImageData.origin` is set to the minimum bounds of the subset
| - the :attr:`~pyvista.ImageData.offset` is reset to ``(0, 0, 0)``
|
| The rebasing effectively applies a positive translation in world (XYZ) coordinates and
| a similar (i.e. inverse) negative translation in voxel (IJK) coordinates. As a result,
| the :attr:`~pyvista.DataSet.bounds` of the output are unchanged, but the coordinate
| reference frame is modified.
|
| Set this to ``False`` to leave the origin unmodified and keep the offset used by the
| crop.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Cropped image.
|
| See Also
| --------
| pad_image
| Add points to image boundaries. This is the inverse operation of the ``margin`` crop.
|
| resample
| Modify an image's dimensions and spacing.
|
| select_values
| Threshold-like filter which may be used to generate a mask for cropping.
|
| extract_subset
| Equivalent filter to ``crop(extent=voi, rebase_coordinates=True)``.
|
| :ref:`crop_labeled_example`
| Example cropping :class:`~pyvista.ImageData` using a segmentation mask.
|
| Examples
| --------
| Load a grayscale image.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> gray_image = examples.download_yinyang()
| >>> gray_image.dimensions
| (512, 342, 1)
|
| Define a custom plotting helper to show the image as pixel cells.
|
| >>> def image_plotter(image):
| ... pixel_cells = image.points_to_cells()
| ...
| ... pl = pv.Plotter()
| ... pl.add_mesh(
| ... pixel_cells,
| ... cmap='gray',
| ... clim=[0, 255],
| ... lighting=False,
| ... show_scalar_bar=False,
| ... )
| ... pl.view_xy()
| ... pl.camera.tight()
| ... return pl
|
| Plot the image for context.
|
| >>> image_plotter(gray_image).show()
|
| Crop the white border around the image using active scalars as a mask. Here we specify a
| background value of ``255`` to correspond to white pixels. If this was an RGB image, we
| could also specify ``(255, 255, 255)`` as the background value.
|
| >>> cropped = gray_image.crop(mask=True, background_value=255)
| >>> cropped.dimensions
| (237, 238, 1)
| >>> image_plotter(cropped).show()
|
| Use ``margin`` instead to remove 100 and 20 pixels from each side of the x- and y-axis,
| respectively.
|
| >>> cropped = gray_image.crop(margin=(100, 20))
| >>> cropped.dimensions
| (312, 302, 1)
| >>> image_plotter(cropped).show()
|
| Use ``offset`` to select a starting location for the crop (from the origin at the
| bottom-left corner) along with ``dimensions`` to define the crop size.
|
| >>> cropped = gray_image.crop(offset=(50, 20, 0), dimensions=(300, 200, 1))
| >>> cropped.dimensions
| (300, 200, 1)
| >>> image_plotter(cropped).show()
|
| Use ``extent`` directly instead of using ``dimensions`` and ``offset`` to yield the same
| result as above.
|
| >>> cropped = gray_image.crop(extent=(50, 349, 20, 219, 0, 0))
| >>> cropped.extent
| (50, 349, 20, 219, 0, 0)
| >>> image_plotter(cropped).show()
|
| Use ``factor`` to crop 40% of the image. This `keeps` 40% of the pixels along each axis,
| and `removes` 60% (i.e. 30% from each side).
|
| >>> cropped = gray_image.crop(factor=0.4)
| >>> cropped.dimensions
| (204, 136, 1)
| >>> image_plotter(cropped).show()
|
| Use ``normalized_bounds`` to crop from 40% to 80% of the image along the x-axis, and
| from 30% to 90% of the image along the y-axis.
|
| >>> cropped = gray_image.crop(normalized_bounds=[0.4, 0.8, 0.3, 0.9, 0.0, 1.0])
| >>> cropped.extent
| (205, 408, 103, 306, 0, 0)
| >>> image_plotter(cropped).show()
|
| dilate(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Morphologically dilate grayscale or binary data.
|
| This filter may be used to dilate grayscale images with continuous data, binary images
| with a single background and foreground value, or multi-label images.
|
| For binary inputs with two unique values, this filter uses :vtk:`vtkImageDilateErode3D`
| by default to perform fast binary dilation over an ellipsoidal neighborhood. Otherwise,
| the slower class :vtk:`vtkImageContinuousDilate3D` is used to perform generalized grayscale
| dilation by replacing each pixel with the maximum over an ellipsoidal neighborhood.
|
| Optionally, the ``binary`` keyword may be used to explicitly control the behavior of the
| filter.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are dilated, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary dilation or continuous dilation is used.
|
| If set, :vtk:`vtkImageDilateErode3D` is used to strictly dilate with two values.
| Set this to ``True`` to dilate the maximum value in ``scalars`` with its minimum value,
| or set it to two values ``[background_value, foreground_value]`` to dilate
| ``foreground_value`` with ``background_value`` explicitly.
|
| Set this to ``False`` to use :vtk:`vtkImageContinuousDilate3D` to perform continuous
| dilation.
|
| By default, ``binary`` is ``True`` if the input has two unique values, and ``False``
| otherwise.
|
| .. note::
| - If the input is a binary mask, setting ``binary=True`` produces the same output
| as ``binary=False``, but the filter is much more performant.
| - Setting ``binary=[background_value, foreground_value]`` is useful to `isolate`
| the dilation to two values, e.g. for multi-label segmentation masks.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been dilated.
|
| See Also
| --------
| erode, open, close
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| .. pyvista-plot::
| :force_static:
|
| Create a toy example with two non-zero grayscale foreground values
| :meth:`padded <pad_image>` with a background of zeros.
|
| >>> import pyvista as pv
| >>> im = pv.ImageData(dimensions=(2, 1, 1))
| >>> im['data'] = [128, 255]
| >>> im = im.pad_image(pad_value=0, pad_size=2, dimensionality=2)
|
| Define a custom plotter to plot pixels as cells.
|
| >>> def image_plotter(image):
| ... pl = pv.Plotter()
| ... pl.add_mesh(
| ... image.points_to_cells(),
| ... cmap='grey',
| ... clim=[0, 255],
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... lighting=False,
| ... line_width=3,
| ... )
| ... pl.camera_position = 'xy'
| ... pl.camera.tight()
| ... pl.enable_anti_aliasing()
| ... return pl
|
| Show the image.
|
| >>> image_plotter(im).show()
|
| Dilate it with default settings. Observe that `both` foreground values are dilated.
|
| >>> dilated = im.dilate()
| >>> image_plotter(dilated).show()
|
| Use a larger kernel size.
|
| >>> dilated = im.dilate(kernel_size=5)
| >>> image_plotter(dilated).show()
|
| Use an asymmetric kernel.
|
| >>> dilated = im.dilate(kernel_size=(2, 4, 1))
| >>> image_plotter(dilated).show()
|
| Use binary dilation. By default, the max value (``255`` in this example) is dilated
| with the min value (``0`` in this example). All other values are unaffected.
|
| >>> dilated = im.dilate(binary=True)
| >>> image_plotter(dilated).show()
|
| Equivalently, set the binary values for the dilation explicitly.
|
| >>> dilated = im.dilate(binary=[0, 255])
| >>> image_plotter(dilated).show()
|
| Use binary dilation with the other foreground value instead.
|
| >>> dilated = im.dilate(binary=[0, 128])
| >>> image_plotter(dilated).show()
|
| erode(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Morphologically erode grayscale or binary data.
|
| This filter may be used to erode grayscale images with continuous data, binary images
| with a single background and foreground value, or multi-label images.
|
| For binary inputs with two unique values, this filter uses :vtk:`vtkImageDilateErode3D`
| by default to perform fast binary erosion over an ellipsoidal neighborhood. Otherwise,
| the slower class :vtk:`vtkImageContinuousErode3D` is used to perform generalized grayscale
| erosion by replacing each pixel with the minimum over an ellipsoidal neighborhood.
|
| Optionally, the ``binary`` keyword may be used to explicitly control the behavior of the
| filter.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are eroded, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary erosion or continuous erosion is used.
|
| If set, :vtk:`vtkImageDilateErode3D` is used to strictly erode with two values.
| Set this to ``True`` to erode the maximum value in ``scalars`` with its minimum value,
| or set it to two values ``[background_value, foreground_value]`` to erode
| ``foreground_value`` with ``background_value`` explicitly.
|
| Set this to ``False`` to use :vtk:`vtkImageContinuousErode3D` to perform continuous
| erosion.
|
| By default, ``binary`` is ``True`` if the input has two unique values, and ``False``
| otherwise.
|
| .. note::
| - If the input is a binary mask, setting ``binary=True`` produces the same output
| as ``binary=False``, but the filter is much more performant.
| - Setting ``binary=[background_value, foreground_value]`` is useful to `isolate`
| the erosion to two values, e.g. for multi-label segmentation masks.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been eroded.
|
| See Also
| --------
| dilate, open, close
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| .. pyvista-plot::
| :force_static:
|
| Create a toy example with two non-zero grayscale foreground regions
| using :meth:`pad_image`.
|
| >>> import pyvista as pv
| >>> # Create an initial background point
| >>> im = pv.ImageData(dimensions=(1, 1, 1))
| >>> im['data'] = [0]
| >>> # Add a foreground region
| >>> im = im.pad_image(pad_value=255, pad_size=(4, 3), dimensionality=2)
| >>> # Add a second foreground region
| >>> im = im.pad_image(pad_value=128, pad_size=(2, 0, 1, 0))
| >>> # Add background values to two sides
| >>> im = im.pad_image(pad_value=0, pad_size=(1, 0))
|
| Define a custom plotter to plot pixels as cells.
|
| >>> def image_plotter(image):
| ... pl = pv.Plotter()
| ... pl.add_mesh(
| ... image.points_to_cells(),
| ... cmap='grey',
| ... clim=[0, 255],
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... lighting=False,
| ... line_width=3,
| ... )
| ... pl.camera_position = 'xy'
| ... pl.camera.tight()
| ... pl.enable_anti_aliasing()
| ... return pl
|
| Show the image.
|
| >>> image_plotter(im).show()
|
| Erode it with default settings. Observe that `both` foreground values are eroded.
|
| >>> eroded = im.erode()
| >>> image_plotter(eroded).show()
|
| Use a larger kernel size.
|
| >>> eroded = im.erode(kernel_size=5)
| >>> image_plotter(eroded).show()
|
| Use an asymmetric kernel.
|
| >>> eroded = im.erode(kernel_size=(2, 4, 1))
| >>> image_plotter(eroded).show()
|
| Use binary erosion. By default, the max value (``255`` in this example) is eroded
| with the min value (``0`` in this example). All other values are unaffected.
|
| >>> eroded = im.erode(binary=True)
| >>> image_plotter(eroded).show()
|
| Equivalently, set the binary values for the erosion explicitly.
|
| >>> eroded = im.erode(binary=[0, 255])
| >>> image_plotter(eroded).show()
|
| Use binary erosion with the other foreground value instead.
|
| >>> eroded = im.erode(binary=[0, 128])
| >>> image_plotter(eroded).show()
|
| extract_subset(self, voi, rate=(1, 1, 1), boundary: 'bool' = False, rebase_coordinates: 'bool' = True, progress_bar: 'bool' = False)
| Select piece (e.g., volume of interest).
|
| To use this filter set the VOI ivar which are i-j-k min/max indices
| that specify a rectangular region in the data. (Note that these are
| 0-offset.) You can also specify a sampling rate to subsample the
| data.
|
| Typical applications of this filter are to extract a slice from a
| volume for image processing, subsampling large volumes to reduce data
| size, or extracting regions of a volume with interesting data.
|
| Parameters
| ----------
| voi : sequence[int]
| Length 6 iterable of ints: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| These bounds specify the volume of interest in i-j-k min/max
| indices.
|
| rate : sequence[int], default: (1, 1, 1)
| Length 3 iterable of ints: ``(xrate, yrate, zrate)``.
|
| boundary : bool, default: False
| Control whether to enforce that the "boundary" of the grid
| is output in the subsampling process. This only has effect
| when the rate in any direction is not equal to 1. When
| this is enabled, the subsampling will always include the
| boundary of the grid even though the sample rate is not an
| even multiple of the grid dimensions. By default this is
| disabled.
|
| rebase_coordinates : bool, default: True
| If ``True`` (default), reset the coordinate reference of the extracted subset:
|
| - the :attr:`~pyvista.ImageData.origin` is set to the minimum bounds of the subset
| - the :attr:`~pyvista.ImageData.offset` is reset to ``(0, 0, 0)``
|
| The rebasing effectively applies a positive translation in world (XYZ) coordinates and
| a similar (i.e. inverse) negative translation in voxel (IJK) coordinates. As a result,
| the :attr:`~pyvista.DataSet.bounds` of the output are unchanged, but the coordinate
| reference frame is modified.
|
| Set this to ``False`` to leave the origin unmodified and keep the offset specified by
| the ``voi`` parameter.
|
| .. versionadded:: 0.46
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| ImageData subset.
|
| See Also
| --------
| slice_index
| crop
|
| fft(self, output_scalars_name=None, progress_bar: 'bool' = False)
| Apply a fast Fourier transform (FFT) to the active scalars.
|
| The input can be real or complex data, but the output is always
| :attr:`numpy.complex128`. The filter is fastest for images that have
| power of two sizes.
|
| The filter uses a butterfly diagram for each prime factor of the
| dimension. This makes images with prime number dimensions (i.e. 17x17)
| much slower to compute. FFTs of multidimensional meshes (i.e volumes)
| are decomposed so that each axis executes serially.
|
| The frequencies of the output assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with applied FFT.
|
| See Also
| --------
| rfft : The reverse transform.
| low_pass : Low-pass filtering of FFT output.
| high_pass : High-pass filtering of FFT output.
|
| Examples
| --------
| Apply FFT to an example image.
|
| >>> from pyvista import examples
| >>> image = examples.download_moonlanding_image()
| >>> fft_image = image.fft()
| >>> fft_image.point_data # doctest:+SKIP
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : PNGImage
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| PNGImage complex128 (298620,) SCALARS
|
| See :ref:`image_fft_example` for a full example using this filter.
|
| gaussian_smooth(self, radius_factor=1.5, std_dev=2.0, scalars=None, progress_bar: 'bool' = False)
| Smooth the data with a Gaussian kernel.
|
| Parameters
| ----------
| radius_factor : float | sequence[float], default: 1.5
| Unitless factor to limit the extent of the kernel.
|
| std_dev : float | sequence[float], default: 2.0
| Standard deviation of the kernel in pixel units.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Uniform grid with smoothed scalars.
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| First, create sample data to smooth. Here, we use
| :func:`pyvista.perlin_noise() <pyvista.core.utilities.features.perlin_noise>`
| to create meaningful data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 5, 8), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1, 0, 1, 0, 1], dim=(20, 20, 20)
| ... )
| >>> grid.plot(show_scalar_bar=False)
|
| Next, smooth the sample data.
|
| >>> smoothed = grid.gaussian_smooth()
| >>> smoothed.plot(show_scalar_bar=False)
|
| See :ref:`gaussian_smoothing_example` for a full example using this filter.
|
| high_pass(self, x_cutoff, y_cutoff, z_cutoff, order=1, output_scalars_name=None, progress_bar: 'bool' = False)
| Perform a Butterworth high pass filter in the frequency domain.
|
| This filter requires that the :class:`ImageData` have a complex point
| scalars, usually generated after the :class:`ImageData` has been
| converted to the frequency domain by a :func:`ImageDataFilters.fft`
| filter.
|
| A :func:`ImageDataFilters.rfft` filter can be used to convert the
| output back into the spatial domain. This filter attenuates low
| frequency components. Input and output are complex arrays with
| datatype :attr:`numpy.complex128`.
|
| The frequencies of the input assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| x_cutoff : float
| The cutoff frequency for the x-axis.
|
| y_cutoff : float
| The cutoff frequency for the y-axis.
|
| z_cutoff : float
| The cutoff frequency for the z-axis.
|
| order : int, default: 1
| The order of the cutoff curve. Given from the equation
| ``1/(1 + (cutoff/freq(i, j))**(2*order))``.
|
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with the applied high pass filter.
|
| See Also
| --------
| fft : Direct fast Fourier transform.
| rfft : Reverse fast Fourier transform.
| low_pass : Low-pass filtering of FFT output.
|
| Examples
| --------
| See :ref:`image_fft_perlin_noise_example` for a full example using this filter.
|
| image_dilate_erode(self, dilate_value=1.0, erode_value=0.0, kernel_size=(3, 3, 3), scalars=None, progress_bar: 'bool' = False)
| Dilates one value and erodes another.
|
| .. deprecated:: 0.47.0
| :meth:`image_dilate_erode` is deprecated. Use :meth:`dilate`, :meth:`erode`,
| :meth:`open`, or :meth:`close` instead.
|
| ``image_dilate_erode`` will dilate one value and erode another. It uses
| an elliptical footprint, and only erodes/dilates on the boundary of the
| two values. The filter is restricted to the X, Y, and Z axes for now.
| It can degenerate to a 2 or 1-dimensional filter by setting the kernel
| size to 1 for a specific axis.
|
| Parameters
| ----------
| dilate_value : float, default: 1.0
| Dilate value in the dataset.
|
| erode_value : float, default: 0.0
| Erode value in the dataset.
|
| kernel_size : sequence[int], default: (3, 3, 3)
| Determines the size of the kernel along the three axes.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been dilated/eroded on the boundary of the specified scalars.
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| Demonstrate image dilate/erode on an example dataset. First, plot
| the example dataset with the active scalars.
|
| >>> from pyvista import examples
| >>> uni = examples.load_uniform()
| >>> uni.plot()
|
| Now, plot the image threshold with ``threshold=[400, 600]``. Note how
| values within the threshold are 1 and outside are 0.
|
| >>> ithresh = uni.image_threshold([400, 600])
| >>> ithresh.plot()
|
| Note how there is a hole in the thresholded image. Apply a closing
| filter with a large kernel to fill that hole in.
|
| >>> iclosed = ithresh.close(kernel_size=[5, 5, 5])
| >>> iclosed.plot()
|
| image_threshold(self: 'ImageData', threshold, in_value=1.0, out_value=0.0, scalars=None, preference='point', progress_bar: 'bool' = False)
| Apply a threshold to scalar values in a uniform grid.
|
| If a single value is given for threshold, scalar values above or equal
| to the threshold are ``'in'`` and scalar values below the threshold are ``'out'``.
| If two values are given for threshold (sequence) then values equal to
| or between the two values are ``'in'`` and values outside the range are ``'out'``.
|
| If ``None`` is given for ``in_value``, scalars that are ``'in'`` will not be replaced.
| If ``None`` is given for ``out_value``, scalars that are ``'out'`` will not be replaced.
|
| Warning: applying this filter to cell data will send the output to a
| new point array with the same name, overwriting any existing point data
| array with the same name.
|
| Parameters
| ----------
| threshold : float or sequence[float]
| Single value or (min, max) to be used for the data threshold. If
| a sequence, then length must be 2. Threshold(s) for deciding which
| cells/points are ``'in'`` or ``'out'`` based on scalar data.
|
| in_value : float, default: 1.0
| Scalars that match the threshold criteria for ``'in'`` will be replaced with this.
|
| out_value : float, default: 0.0
| Scalars that match the threshold criteria for ``'out'`` will be replaced with this.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset with the specified scalars thresholded.
|
| See Also
| --------
| select_values
| Threshold-like method for keeping some values and replacing others.
| :meth:`~pyvista.DataSetFilters.threshold`
| General threshold method that returns a :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Demonstrate image threshold on an example dataset. First, plot
| the example dataset with the active scalars.
|
| >>> from pyvista import examples
| >>> uni = examples.load_uniform()
| >>> uni.plot()
|
| Now, plot the image threshold with ``threshold=100``. Note how
| values above the threshold are 1 and below are 0.
|
| >>> ithresh = uni.image_threshold(100)
| >>> ithresh.plot()
|
| See :ref:`image_representations_example` for more examples using this filter.
|
| label_connectivity(self, *, scalars: 'str | None' = None, scalar_range: "Literal['auto', 'foreground', 'vtk_default'] | VectorLike[float]" = 'auto', extraction_mode: "Literal['all', 'largest', 'seeded']" = 'all', point_seeds: 'MatrixLike[float] | VectorLike[float] | _vtk.vtkDataSet | None' = None, label_mode: "Literal['size', 'constant', 'seeds']" = 'size', constant_value: 'int | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False) -> 'tuple[ImageData, NDArray[int], NDArray[int]]'
| Find and label connected regions in a :class:`~pyvista.ImageData`.
|
| Only points whose `scalar` value is within the `scalar_range` are considered for
| connectivity. A 4-connectivity is used for 2D images or a 6-connectivity for 3D
| images. This filter operates on point-based data. If cell-based data are provided,
| they are re-meshed to a point-based representation using
| :func:`~pyvista.ImageDataFilters.cells_to_points` and the output is meshed back
| to a cell-based representation with :func:`~pyvista.ImageDataFilters.points_to_cells`,
| effectively filtering based on face connectivity. The connected regions are
| extracted and labelled according to the strategy defined by ``extraction_mode``
| and ``label_mode``, respectively. Unconnected regions are labelled with ``0`` value.
|
| .. versionadded:: 0.45.0
|
| Notes
| -----
| This filter implements :vtk:`vtkImageConnectivityFilter`.
|
| Parameters
| ----------
| scalars : str, optional
| Scalars to use to filter points. If ``None`` is provided, the scalars is
| automatically set, if possible.
|
| scalar_range : str, Literal['auto', 'foreground', 'vtk_default'], VectorLike[float]
| Points whose scalars value is within ``'scalar_range'`` are considered for
| connectivity. The bounds are inclusive.
|
| - ``'auto'``: (default) includes the full data range, similarly to
| :meth:`~pyvista.DataSetFilters.connectivity`.
| - ``'foreground'``: includes the full data range except the smallest value.
| - ``'vtk_default'``: default to [``0.5``, :const:`~vtk.VTK_DOUBLE_MAX`].
| - ``VectorLike[float]``: explicitly set the range.
|
| The bounds are always cast to floats since vtk expects doubles. The scalars
| data are also cast to floats to avoid unexpected behavior arising from implicit
| type conversion. The only exceptions is if both bounds are whole numbers, in
| which case the implicit conversion is safe. It will optimize resources consumption
| if the data are integers.
|
| extraction_mode : Literal['all', 'largest', 'seeded'], default: 'all'
| Determine how the connected regions are extracted. If ``'all'``, all connected
| regions are extracted. If ``'largest'``, only the largest region is extracted.
| If ``'seeded'``, only the regions that include the points defined with
| ``point_seeds`` are extracted.
|
| point_seeds : MatrixLike[float], VectorLike[float], :vtk:`vtkDataSet`, optional
| The point coordinates to use as seeds, specified as a (N, 3) array like or
| as a :vtk:`vtkDataSet`. Has no effect if ``extraction_mode`` is not
| ``'seeded'``.
|
| label_mode : Literal['size', 'constant', 'seeds'], default: 'size'
| Determine how the extracted regions are labelled. If ``'size'``, label regions
| by decreasing size (i.e., count of cells), starting at ``1``. If ``'constant'``,
| label with the provided ``constant_value``. If ``'seeds'``, label according to
| the seed order, starting at ``1``.
|
| constant_value : int, optional
| The constant label value to use. Has no effect if ``label_mode`` is not ``'seeds'``.
|
| inplace : bool, default: False
| If ``True``, perform an inplace labelling of the ImageData. Else, returns a
| new ImageData.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Either the input ImageData or a generated one where connected regions are
| labelled with a ``'RegionId'`` point-based or cell-based data.
|
| NDArray[int]
| The labels of each extracted regions.
|
| NDArray[int]
| The size (i.e., number of cells) of each extracted regions.
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Similar general-purpose filter that performs 1-connectivity.
|
| Examples
| --------
| Prepare a segmented grid.
|
| >>> import pyvista as pv
| >>> segmented_grid = pv.ImageData(dimensions=(4, 3, 3))
| >>> segmented_grid.cell_data['Data'] = [
| ... 0,
| ... 0,
| ... 0,
| ... 1,
| ... 0,
| ... 1,
| ... 1,
| ... 2,
| ... 0,
| ... 0,
| ... 0,
| ... 0,
| ... ]
| >>> segmented_grid.plot(show_edges=True)
|
| Label the connected regions. The cells with a ``0`` value are excluded from the
| connected regions and labelled with ``0``. The remaining cells define 3 different
| regions that are labelled by decreasing size.
|
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range='foreground'
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| Exclude the cell with a ``2`` value.
|
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range=[1, 1]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| Label all connected regions with a constant value.
|
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range='foreground',
| ... label_mode='constant',
| ... constant_value=10,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| Label only the regions that include seed points, by seed order.
|
| >>> points = [(2.0, 1.0, 0.0), (0.0, 0.0, 1.0)]
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range='foreground',
| ... extraction_mode='seeded',
| ... point_seeds=points,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| low_pass(self, x_cutoff, y_cutoff, z_cutoff, order=1, output_scalars_name=None, progress_bar: 'bool' = False)
| Perform a Butterworth low pass filter in the frequency domain.
|
| This filter requires that the :class:`ImageData` have a complex point
| scalars, usually generated after the :class:`ImageData` has been
| converted to the frequency domain by a :func:`ImageDataFilters.fft`
| filter.
|
| A :func:`ImageDataFilters.rfft` filter can be used to convert the
| output back into the spatial domain. This filter attenuates high
| frequency components. Input and output are complex arrays with
| datatype :attr:`numpy.complex128`.
|
| The frequencies of the input assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| x_cutoff : float
| The cutoff frequency for the x-axis.
|
| y_cutoff : float
| The cutoff frequency for the y-axis.
|
| z_cutoff : float
| The cutoff frequency for the z-axis.
|
| order : int, default: 1
| The order of the cutoff curve. Given from the equation
| ``1 + (cutoff/freq(i, j))**(2*order)``.
|
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with the applied low pass filter.
|
| See Also
| --------
| fft : Direct fast Fourier transform.
| rfft : Reverse fast Fourier transform.
| high_pass : High-pass filtering of FFT output.
|
| Examples
| --------
| See :ref:`image_fft_perlin_noise_example` for a full example using this filter.
|
| median_smooth(self, kernel_size=(3, 3, 3), scalars=None, preference='point', progress_bar: 'bool' = False)
| Smooth data using a median filter.
|
| The Median filter that replaces each pixel with the median value from a
| rectangular neighborhood around that pixel. Neighborhoods can be no
| more than 3 dimensional. Setting one axis of the neighborhood
| kernelSize to 1 changes the filter into a 2D median.
|
| See :vtk:`vtkImageMedian3D` for more details.
|
| Parameters
| ----------
| kernel_size : sequence[int], default: (3, 3, 3)
| Size of the kernel in each dimension (units of voxels), for example
| ``(x_size, y_size, z_size)``. Default is a 3D median filter. If you
| want to do a 2D median filter, set the size to 1 in the dimension
| you don't want to filter over.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Uniform grid with smoothed scalars.
|
| Warnings
| --------
| Applying this filter to cell data will send the output to a new point
| array with the same name, overwriting any existing point data array
| with the same name.
|
| Examples
| --------
| First, create sample data to smooth. Here, we use
| :func:`pyvista.perlin_noise() <pyvista.core.utilities.features.perlin_noise>`
| to create meaningful data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 5, 8), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1, 0, 1, 0, 1], dim=(20, 20, 20)
| ... )
| >>> grid.plot(show_scalar_bar=False)
|
| Next, smooth the sample data.
|
| >>> smoothed = grid.median_smooth(kernel_size=(10, 10, 10))
| >>> smoothed.plot(show_scalar_bar=False)
|
| open(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Perform morphological opening on continuous or binary data.
|
| Opening is an :meth:`erosion <erode>` followed by a :meth:`dilation <dilate>`.
| It is used to remove small objects/noise while preserving the shape and size of larger
| objects.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are opened, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary opening or continuous opening is used. Refer to
| :meth:`erode` and/or :meth:`dilate` for details about using this keyword.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been opened.
|
| See Also
| --------
| close, erode, dilate
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| Load a grayscale image :func:`~pyvista.examples.downloads.download_chest()` and show it
| for context.
|
| >>> from pyvista import examples
| >>> im = examples.download_chest()
| >>> clim = im.get_data_range()
| >>> kwargs = dict(
| ... cmap='grey',
| ... clim=clim,
| ... lighting=False,
| ... cpos='xy',
| ... zoom='tight',
| ... show_axes=False,
| ... show_scalar_bar=False,
| ... )
| >>> im.plot(**kwargs)
|
| Use ``open`` to remove small objects in the lungs.
|
| >>> opened = im.open(kernel_size=15)
| >>> opened.plot(**kwargs)
|
| pad_image(self, pad_value: "float | VectorLike[float] | Literal['wrap', 'mirror']" = 0.0, *, pad_size: 'int | VectorLike[int]' = 1, dimensionality: "VectorLike[bool] | Literal[0, 1, 2, 3, '0D', '1D', '2D', '3D', 'preserve']" = 'preserve', scalars: 'str | None' = None, pad_all_scalars: 'bool' = False, progress_bar: 'bool' = False) -> 'ImageData'
| Enlarge an image by padding its boundaries with new points.
|
| .. versionadded:: 0.44.0
|
| Padded points may be mirrored, wrapped, or filled with a constant value. By
| default, all boundaries of the image are padded with a single constant value.
|
| This filter is designed to work with 1D, 2D, or 3D image data and will only pad
| non-singleton dimensions unless otherwise specified.
|
| Parameters
| ----------
| pad_value : float | sequence[float] | 'mirror' | 'wrap', default: 0.0
| Padding value(s) given to new points outside the original image extent.
| Specify:
|
| - a number: New points are filled with the specified constant value.
| - a vector: New points are filled with the specified multi-component vector.
| - ``'wrap'``: New points are filled by wrapping around the padding axis.
| - ``'mirror'``: New points are filled by mirroring the padding axis.
|
| pad_size : int | sequence[int], default: 1
| Number of points to add to the image boundaries. Specify:
|
| - A single value to pad all boundaries equally.
| - Two values, one for each ``(X, Y)`` axis, to apply symmetric padding to
| each axis independently.
| - Three values, one for each ``(X, Y, Z)`` axis, to apply symmetric padding
| to each axis independently.
| - Four values, one for each ``(-X, +X, -Y, +Y)`` boundary, to apply
| padding to each boundary independently.
| - Six values, one for each ``(-X, +X, -Y, +Y, -Z, +Z)`` boundary, to apply
| padding to each boundary independently.
|
| dimensionality : VectorLike[bool], Literal[1, 2, 3, "1D", "2D", "3D", "preserve"]
| Control which dimensions will be padded by the filter.
| ``'preserve'`` is used by default.
|
| - Can be specified as a sequence of 3 boolean to apply padding on a per
| dimension basis.
| - ``1`` or ``'1D'``: apply padding such that the output is a 1D ImageData
| where exactly one dimension is greater than one, e.g. ``(>1, 1, 1)``.
| Only valid for 0D or 1D inputs.
| - ``2`` or ``'2D'``: apply padding such that the output is a 2D ImageData
| where exactly two dimensions are greater than one, e.g. ``(>1, >1, 1)``.
| Only valid for 0D, 1D, or 2D inputs.
| - ``3`` or ``'3D'``: apply padding such that the output is a 3D ImageData,
| where all three dimensions are greater than one, e.g. ``(>1, >1, >1)``.
| Valid for any 0D, 1D, 2D, or 3D inputs.
|
| .. note::
| The ``pad_size`` for singleton dimensions is set to ``0`` by default, even
| if non-zero pad sizes are specified for these axes with this parameter.
| Set ``dimensionality`` to a value different than ``'preserve'`` to
| override this behavior and enable padding any or all dimensions.
|
| .. versionadded:: 0.45.0
|
| scalars : str, optional
| Name of scalars to pad. Defaults to currently active scalars. Unless
| ``pad_all_scalars`` is ``True``, only the specified ``scalars`` are included
| in the output.
|
| pad_all_scalars : bool, default: False
| Pad all point data scalars and include them in the output. This is useful
| for padding images with multiple scalars. If ``False``, only the specified
| ``scalars`` are padded.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Padded image.
|
| See Also
| --------
| crop, resample, contour_labels
|
| Examples
| --------
| Pad a grayscale image with a 100-pixel wide border. The padding is black
| (i.e. has a value of ``0``) by default.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>>
| >>> gray_image = examples.download_moonlanding_image()
| >>> gray_image.dimensions
| (630, 474, 1)
| >>> padded = gray_image.pad_image(pad_size=100)
| >>> padded.dimensions
| (830, 674, 1)
|
| Plot the image. To show grayscale images correctly, we define a custom plotting
| method.
|
| >>> def grayscale_image_plotter(image):
| ... import vtk
| ...
| ... actor = vtk.vtkImageActor()
| ... actor.GetMapper().SetInputData(image)
| ... actor.GetProperty().SetInterpolationTypeToNearest()
| ... pl = pv.Plotter()
| ... pl.add_actor(actor)
| ... pl.view_xy()
| ... pl.camera.tight()
| ... return pl
| >>>
| >>> pl = grayscale_image_plotter(padded)
| >>> pl.show()
|
| Pad only the x-axis with a white border.
|
| >>> padded = gray_image.pad_image(pad_value=255, pad_size=(200, 0))
| >>> pl = grayscale_image_plotter(padded)
| >>> pl.show()
|
| Pad with wrapping.
|
| >>> padded = gray_image.pad_image('wrap', pad_size=100)
| >>> plot = grayscale_image_plotter(padded)
| >>> plot.show()
|
| Pad with mirroring.
|
| >>> padded = gray_image.pad_image('mirror', pad_size=100)
| >>> plot = grayscale_image_plotter(padded)
| >>> plot.show()
|
| Pad a color image using multi-component color vectors. Here, RGBA values are
| used.
|
| >>> color_image = examples.download_beach()
| >>> red = (255, 0, 0) # RGB
| >>> padded = color_image.pad_image(pad_value=red, pad_size=50)
| >>>
| >>> plot_kwargs = dict(cpos='xy', zoom='tight', rgb=True, show_axes=False)
| >>> padded.plot(**plot_kwargs)
|
| Pad each edge of the image separately with a different color.
|
| >>> orange = pv.Color('orange').int_rgb
| >>> purple = pv.Color('purple').int_rgb
| >>> blue = pv.Color('blue').int_rgb
| >>> green = pv.Color('green').int_rgb
| >>>
| >>> padded = color_image.pad_image(orange, pad_size=(25, 0, 0, 0))
| >>> padded = padded.pad_image(purple, pad_size=(0, 25, 0, 0))
| >>> padded = padded.pad_image(blue, pad_size=(0, 0, 25, 0))
| >>> padded = padded.pad_image(green, pad_size=(0, 0, 0, 25))
| >>>
| >>> padded.plot(**plot_kwargs)
|
| points_to_cells(self: 'ImageData', scalars: 'str | None' = None, *, dimensionality: "VectorLike[bool] | Literal[0, 1, 2, 3, '0D', '1D', '2D', '3D', 'preserve']" = 'preserve', copy: 'bool' = True)
| Re-mesh image data from a point-based to a cell-based representation.
|
| This filter changes how image data is represented. Data represented as points
| at the input is re-meshed into an alternative representation as cells at the
| output. Only the :class:`~pyvista.ImageData` container is modified so that
| the number of input points equals the number of output cells. The re-meshing is
| otherwise lossless in the sense that point data at the input is passed through
| unmodified and stored as cell data at the output. Any cell data at the input is
| ignored and is not used by this filter.
|
| To change the image data's representation, the input points are used to
| represent the centers of the output cells. This has the effect of "growing" the
| input image dimensions by one along each axis (i.e. half the cell width on each
| side). For example, an image with 100 points and 99 cells along an axis at the
| input will have 101 points and 100 cells at the output. If the input has 1mm
| spacing, the axis size will also increase from 99mm to 100mm. By default,
| only non-singleton dimensions are increased such that 1D or 2D inputs remain
| 1D or 2D at the output.
|
| Since filters may be inherently cell-based (e.g. some :class:`~pyvista.DataSetFilters`)
| or may operate on point data exclusively (e.g. most :class:`~pyvista.ImageDataFilters`),
| re-meshing enables the same data to be used with either kind of filter while
| ensuring the input data to those filters has the appropriate representation.
| This filter is also useful when plotting image data to achieve a desired visual
| effect, such as plotting images as voxel cells instead of as points.
|
| .. note::
| Only the input's :attr:`~pyvista.ImageData.dimensions`, and
| :attr:`~pyvista.ImageData.origin` are modified by this filter. Other spatial
| properties such as :attr:`~pyvista.ImageData.spacing` and
| :attr:`~pyvista.ImageData.direction_matrix` are not affected.
|
| .. versionadded:: 0.44.0
|
| See Also
| --------
| cells_to_points
| Inverse of this filter to represent cells as points.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample point data as cell data without modifying the container.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample cell data as point data without modifying the container.
|
| Parameters
| ----------
| scalars : str, optional
| Name of point data scalars to pass through to the output as cell data. Use
| this parameter to restrict the output to only include the specified array.
| By default, all point data arrays at the input are passed through as cell
| data at the output.
|
| dimensionality : VectorLike[bool], Literal[0, 1, 2, 3, "0D", "1D", "2D", "3D", "preserve"]
| Control which dimensions will be modified by the filter.
| ``'preserve'`` is used by default.
|
| - Can be specified as a sequence of 3 boolean to allow modification on a per
| dimension basis.
| - ``0`` or ``'0D'``: convenience alias to output a 0D ImageData with
| dimensions ``(1, 1, 1)``. Only valid for 0D inputs.
| - ``1`` or ``'1D'``: convenience alias to output a 1D ImageData where
| exactly one dimension is greater than one, e.g. ``(>1, 1, 1)``. Only valid
| for 0D or 1D inputs.
| - ``2`` or ``'2D'``: convenience alias to output a 2D ImageData where
| exactly two dimensions are greater than one, e.g. ``(>1, >1, 1)``. Only
| valid for 0D, 1D, or 2D inputs.
| - ``3`` or ``'3D'``: convenience alias to output a 3D ImageData, where all
| three dimensions are greater than one, e.g. ``(>1, >1, >1)``. Valid for
| any 0D, 1D, 2D, or 3D inputs.
| - ``'preserve'`` (default): convenience alias to not modify singleton
| dimensions.
|
| copy : bool, default: True
| Copy the input point data before associating it with the output cell data.
| If ``False``, the input and output will both refer to the same data array(s).
|
| Returns
| -------
| pyvista.ImageData
| Image with a cell-based representation.
|
| Examples
| --------
| Load an image with point data.
|
| >>> from pyvista import examples
| >>> image = examples.load_uniform()
|
| Show the current properties and point arrays of the image.
|
| >>> image
| ImageData (...)
| N Cells: 729
| N Points: 1000
| X Bounds: 0.000e+00, 9.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| Dimensions: 10, 10, 10
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 2
|
| >>> image.point_data.keys()
| ['Spatial Point Data']
|
| Re-mesh the points and point data as cells and cell data.
|
| >>> cells_image = image.points_to_cells()
|
| Show the properties and cell arrays of the re-meshed image.
|
| >>> cells_image
| ImageData (...)
| N Cells: 1000
| N Points: 1331
| X Bounds: -5.000e-01, 9.500e+00
| Y Bounds: -5.000e-01, 9.500e+00
| Z Bounds: -5.000e-01, 9.500e+00
| Dimensions: 11, 11, 11
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> cells_image.cell_data.keys()
| ['Spatial Point Data']
|
| Observe that:
|
| - The input point array is now a cell array
| - The output has one less array (the input cell data is ignored)
| - The dimensions have increased by one
| - The bounds have increased by half the spacing
| - The output ``N Cells`` equals the input ``N Points``
|
| Since the input points are 3D (i.e. there are no singleton dimensions), the
| output cells are 3D :attr:`~pyvista.CellType.VOXEL` cells.
|
| >>> cells_image.get_cell(0).type
| <CellType.VOXEL: 11>
|
| If the input points are 2D (i.e. one dimension is singleton), the
| output cells are 2D :attr:`~pyvista.CellType.PIXEL` cells when ``dimensions`` is
| set to ``'preserve'``.
|
| >>> image2D = examples.download_beach()
| >>> image2D.dimensions
| (100, 100, 1)
|
| >>> pixel_cells_image = image2D.points_to_cells(dimensionality='preserve')
| >>> pixel_cells_image.dimensions
| (101, 101, 1)
| >>> pixel_cells_image.get_cell(0).type
| <CellType.PIXEL: 8>
|
| This is equivalent as requesting a 2D output.
|
| >>> pixel_cells_image = image2D.points_to_cells(dimensionality='2D')
| >>> pixel_cells_image.dimensions
| (101, 101, 1)
| >>> pixel_cells_image.get_cell(0).type
| <CellType.PIXEL: 8>
|
| Use ``(True, True, True)`` to re-mesh 2D points as 3D cells.
|
| >>> voxel_cells_image = image2D.points_to_cells(
| ... dimensionality=(True, True, True)
| ... )
| >>> voxel_cells_image.dimensions
| (101, 101, 2)
| >>> voxel_cells_image.get_cell(0).type
| <CellType.VOXEL: 11>
|
| Or request a 3D output.
|
| >>> voxel_cells_image = image2D.points_to_cells(dimensionality='3D')
| >>> voxel_cells_image.dimensions
| (101, 101, 2)
| >>> voxel_cells_image.get_cell(0).type
| <CellType.VOXEL: 11>
|
| See :ref:`image_representations_example` for more examples using this filter.
|
| resample(self: 'ImageData', sample_rate: 'float | VectorLike[float] | None' = None, interpolation: '_InterpolationOptions' = 'nearest', *, border_mode: "Literal['clamp', 'wrap', 'mirror']" = 'clamp', reference_image: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, anti_aliasing: 'bool' = False, extend_border: 'bool | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Resample the image to modify its dimensions and spacing.
|
| The resampling can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_image``.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``sample_rate`` explicitly.
|
| Use ``reference_image`` for full control of the resampled geometry. For
| all other options, the geometry is implicitly defined such that the resampled
| image fits the bounds of the input.
|
| This filter may be used to resample either point or cell data. For point data,
| this filter assumes the data is from discrete samples in space which represent
| pixels or voxels; the resampled bounds are therefore extended by 1/2 voxel
| spacing by default though this may be disabled.
|
| .. note::
|
| Singleton dimensions are not resampled by this filter, e.g. 2D images
| will remain 2D.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| sample_rate : float | VectorLike[float], optional
| Sampling rate(s) to use. Can be a single value or vector of three values
| for each axis. Values greater than ``1.0`` will up-sample the axis and
| values less than ``1.0`` will down-sample it. Values must be greater than ``0``.
|
| interpolation : 'nearest', 'linear', 'cubic', 'lanczos', 'hamming', 'blackman', 'bspline'
| Interpolation mode to use.
|
| - ``'nearest'`` (default) duplicates (if upsampling) or removes (if downsampling)
| values but does not modify them.
| - ``'linear'`` and ``'cubic'`` use linear and cubic interpolation, respectively.
| - ``'lanczos'``, ``'hamming'``, and ``'blackman'`` use a windowed sinc filter
| and may be used to preserve sharp details and/or reduce image artifacts.
| - ``'bspline'`` uses an n-degree basis spline to smoothly interpolate across points.
| The default degree is ``3``, but can range from ``0`` to ``9``. Append the desired
| degree to the string to set it, e.g. ``'bspline5'`` for a 5th-degree B-spline.
|
| .. versionadded:: 0.47
| Added ``'bspline'`` interpolation.
|
| .. note::
|
| - use ``'nearest'`` for pixel art or categorical data such as segmentation masks
| - use ``'linear'`` for speed-critical tasks
| - use ``'cubic'`` for upscaling or general-purpose resampling
| - use ``'lanczos'`` for high-detail downsampling (at the cost of some ringing)
| - use ``'blackman'`` for minimizing ringing artifacts (at the cost of some detail)
| - use ``'hamming'`` for a balance between detail-preservation and reducing ringing
|
| border_mode : 'clamp' | 'wrap' | 'mirror', default: 'clamp'
| Controls the interpolation at the image's borders.
|
| - ``'clamp'`` - values outside the image are clamped to the nearest edge.
| - ``'wrap'`` - values outside the image are wrapped periodically along the axis.
| - ``'mirror'`` - values outside the image are mirrored at the boundary.
|
| .. versionadded:: 0.47
|
| reference_image : ImageData, optional
| Reference image to use. If specified, the input is resampled
| to match the geometry of the reference. The :attr:`~pyvista.ImageData.dimensions`,
| :attr:`~pyvista.ImageData.spacing`, :attr:`~pyvista.ImageData.origin`,
| :attr:`~pyvista.ImageData.offset`, and :attr:`~pyvista.ImageData.direction_matrix`
| of the resampled image will all match the reference image.
|
| dimensions : VectorLike[int], optional
| Set the output :attr:`~pyvista.ImageData.dimensions` of the resampled image.
|
| .. note::
|
| Dimensions is the number of `points` along each axis. If resampling
| `cell` data, each dimension should be one more than the number of
| desired output cells (since there are ``N`` cells and ``N+1`` points
| along each axis). See examples.
|
| anti_aliasing : bool, default: False
| Enable antialiasing. This will blur the image as part of the resampling
| to reduce image artifacts when down-sampling. Has no effect when up-sampling.
|
| extend_border : bool, optional
| Extend the apparent input border by approximately half the
| :attr:`~pyvista.ImageData.spacing`. If enabled, the bounds of the
| resampled points will be larger than the input image bounds.
| Enabling this option also has the effect that the re-sampled spacing
| will directly correlate with the resampled dimensions, e.g. if
| the dimensions are doubled the spacing will be halved. See examples.
|
| This option is enabled by default when resampling point data. Has no effect
| when resampling cell data or when a ``reference_image`` is provided.
|
| scalars : str, optional
| Name of scalars to resample. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When scalars is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| inplace : bool, default: False
| If ``True``, resample the image inplace. By default, a new
| :class:`~pyvista.ImageData` instance is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Resampled image.
|
| See Also
| --------
| crop
| Crop image to remove points at the image's boundaries.
|
| :meth:`~pyvista.DataObjectFilters.sample`
| Resample array data from one mesh onto another.
|
| :meth:`~pyvista.DataSetFilters.interpolate`
| Interpolate values from one mesh onto another.
|
| :ref:`image_representations_example`
| Compare images represented as points vs. cells.
|
| Examples
| --------
| Create a small 2D grayscale image with dimensions ``3 x 2`` for demonstration.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> from pyvista import examples
| >>> image = pv.ImageData(dimensions=(3, 2, 1))
| >>> image.point_data['data'] = np.linspace(0, 255, 6, dtype=np.uint8)
|
| Define a custom plotter to show the image. Although the image data is defined
| as point data, we use :meth:`points_to_cells` to display the image as
| :attr:`~pyvista.CellType.PIXEL` (or :attr:`~pyvista.CellType.VOXEL`) cells
| instead. Grayscale coloring is used and the camera is adjusted to fit the image.
|
| >>> def image_plotter(image: pv.ImageData, clim=(0, 255)) -> pv.Plotter:
| ... pl = pv.Plotter()
| ... image = image.points_to_cells()
| ... pl.add_mesh(
| ... image,
| ... lighting=False,
| ... show_edges=True,
| ... cmap='grey',
| ... clim=clim,
| ... show_scalar_bar=False,
| ... line_width=3,
| ... )
| ... pl.view_xy()
| ... pl.camera.tight()
| ... pl.enable_anti_aliasing()
| ... return pl
|
| Show the image.
|
| >>> plot = image_plotter(image)
| >>> plot.show()
|
| Use ``sample_rate`` to up-sample the image. ``'nearest'`` interpolation is
| used by default.
|
| >>> upsampled = image.resample(sample_rate=2.0)
| >>> plot = image_plotter(upsampled)
| >>> plot.show()
|
| Use ``'linear'`` interpolation. Note that the argument names ``sample_rate``
| and ``interpolation`` may be omitted.
|
| >>> upsampled = image.resample(2.0, 'linear')
| >>> plot = image_plotter(upsampled)
| >>> plot.show()
|
| Use ``'cubic'`` interpolation. Here we also specify the output
| ``dimensions`` explicitly instead of using ``sample_rate``.
|
| >>> upsampled = image.resample(dimensions=(6, 4, 1), interpolation='cubic')
| >>> plot = image_plotter(upsampled)
| >>> plot.show()
|
| Compare the relative physical size of the image before and after resampling.
|
| >>> image
| ImageData (...)
| N Cells: 2
| N Points: 6
| X Bounds: 0.000e+00, 2.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 3, 2, 1
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> upsampled
| ImageData (...)
| N Cells: 15
| N Points: 24
| X Bounds: -2.500e-01, 2.250e+00
| Y Bounds: -2.500e-01, 1.250e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 6, 4, 1
| Spacing: 5.000e-01, 5.000e-01, 1.000e+00
| N Arrays: 1
|
| Note that the upsampled :attr:`~pyvista.ImageData.dimensions` are doubled and
| the :attr:`~pyvista.ImageData.spacing` is halved (as expected). Also note,
| however, that the physical bounds of the input differ from the output.
| The upsampled :attr:`~pyvista.ImageData.origin` also differs:
|
| >>> image.origin
| (0.0, 0.0, 0.0)
| >>> upsampled.origin
| (-0.25, -0.25, 0.0)
|
| This is because the resampling is done with ``extend_border`` enabled by default
| which adds a half cell-width border to the image and adjusts the origin and
| spacing such that the bounds match when the image is represented as cells.
|
| Apply :meth:`points_to_cells` to the input and resampled images and show that
| the bounds match.
|
| >>> image_as_cells = image.points_to_cells()
| >>> image_as_cells.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = 0.0,
| z_max = 0.0)
|
| >>> upsampled_as_cells = upsampled.points_to_cells()
| >>> upsampled_as_cells.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = 0.0,
| z_max = 0.0)
|
| Plot the two images together as wireframe to visualize them. The original is in
| red, and the resampled image is in black.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... image_as_cells, style='wireframe', color='red', line_width=10
| ... )
| >>> _ = pl.add_mesh(
| ... upsampled_as_cells, style='wireframe', color='black', line_width=2
| ... )
| >>> pl.view_xy()
| >>> pl.camera.tight()
| >>> pl.show()
|
| Disable ``extend_border`` to force the input and output bounds of the points
| to be the same instead.
|
| >>> upsampled = image.resample(sample_rate=2, extend_border=False)
|
| Compare the two images again.
|
| >>> image
| ImageData (...)
| N Cells: 2
| N Points: 6
| X Bounds: 0.000e+00, 2.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 3, 2, 1
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> upsampled
| ImageData (...)
| N Cells: 15
| N Points: 24
| X Bounds: 0.000e+00, 2.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 6, 4, 1
| Spacing: 4.000e-01, 3.333e-01, 1.000e+00
| N Arrays: 1
|
| This time the input and output bounds match without any further processing.
| Like before, the dimensions have doubled; unlike before, however, the spacing is
| not halved, but is instead smaller than half which is necessary to ensure the
| bounds remain the same. Also unlike before, the origin is unaffected:
|
| >>> image.origin
| (0.0, 0.0, 0.0)
| >>> upsampled.origin
| (0.0, 0.0, 0.0)
|
| All the above examples are with 2D images with point data. However, the filter
| also works with 3D volumes and will also work with cell data.
|
| Convert the 2D image with point data into a 3D volume with cell data and plot
| it for context.
|
| >>> volume = image.points_to_cells(dimensionality='3D')
| >>> volume.plot(show_edges=True, cmap='grey')
|
| Up-sample the volume. Set the sampling rate for each axis separately.
|
| >>> resampled = volume.resample(sample_rate=(3.0, 2.0, 1.0))
| >>> resampled.plot(show_edges=True, cmap='grey')
|
| Alternatively, we could have set the dimensions explicitly. Since we want
| ``9 x 4 x 1`` cells along the x-y-z axes (respectively), we set the dimensions
| to ``(10, 5, 2)``, i.e. one more than the desired number of cells.
|
| >>> resampled = volume.resample(dimensions=(10, 5, 2))
| >>> resampled.plot(show_edges=True, cmap='grey')
|
| Compare the bounds before and after resampling. Unlike with point data, the
| bounds are not (and cannot be) extended.
|
| >>> volume.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = -0.5,
| z_max = 0.5)
| >>> resampled.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = -0.5,
| z_max = 0.5)
|
| Use a reference image to control the resampling instead. Here we load two
| images with different dimensions:
| :func:`~pyvista.examples.downloads.download_bird` and
| :func:`~pyvista.examples.downloads.download_gourds`.
|
| >>> bird = examples.download_bird()
| >>> bird.dimensions
| (458, 342, 1)
|
| >>> gourds = examples.download_gourds()
| >>> gourds.dimensions
| (640, 480, 1)
|
| Use ``reference_image`` to resample the bird to match the gourds geometry or
| vice-versa.
|
| >>> bird_resampled = bird.resample(reference_image=gourds)
| >>> bird_resampled.dimensions
| (640, 480, 1)
|
| >>> gourds_resampled = gourds.resample(reference_image=bird)
| >>> gourds_resampled.dimensions
| (458, 342, 1)
|
| Downsample the gourds image to 1/10th its original resolution using ``'lanczos'``
| interpolation.
|
| >>> downsampled = gourds.resample(1 / 8, 'lanczos')
| >>> downsampled.dimensions
| (80, 60, 1)
|
| Compare the downsampled image to the original and zoom in to show detail.
|
| >>> def compare_images_plotter(image1, image2):
| ... pl = pv.Plotter(shape=(1, 2))
| ... _ = pl.add_mesh(image1, rgba=True, show_edges=False, lighting=False)
| ... pl.subplot(0, 1)
| ... _ = pl.add_mesh(image2, rgba=True, show_edges=False, lighting=False)
| ... pl.link_views()
| ... pl.view_xy()
| ... pl.camera.zoom(3.0)
| ... return pl
|
| >>> pl = compare_images_plotter(gourds, downsampled)
| >>> pl.show()
|
| Note that downsampling can create image artifacts caused by aliasing. Enable
| anti-aliasing to smooth the image before resampling.
|
| >>> downsampled2 = gourds.resample(1 / 8, 'lanczos', anti_aliasing=True)
|
| Compare down-sampling with aliasing (left) to without aliasing (right).
|
| >>> pl = compare_images_plotter(downsampled, downsampled2)
| >>> pl.show()
|
| Load an MRI of a knee and downsample it.
|
| >>> knee = pv.examples.download_knee().resample(
| ... 0.1, 'linear', anti_aliasing=True
| ... )
|
| Crop and plot it.
|
| >>> knee = knee.crop(normalized_bounds=[0.2, 0.8, 0.2, 0.8, 0.0, 1.0])
| >>> vmin = knee.active_scalars.min()
| >>> vmax = knee.active_scalars.max()
| >>> pl = image_plotter(knee, clim=[vmin, vmax])
| >>> pl.show()
|
| Upsample it with B-spline interpolation. The interpolation is very smooth.
|
| >>> upsampled = knee.resample(2.0, 'bspline', border_mode='clamp')
| >>> pl = image_plotter(upsampled, clim=[vmin, vmax])
| >>> pl.show()
|
| Use the ``'wrap'`` border mode. Note how points at the border are brighter than previously,
| since the bright pixels from the opposite edge are now included in the interpolation.
|
| >>> upsampled = knee.resample(2.0, 'bspline', border_mode='wrap')
| >>> pl = image_plotter(upsampled, clim=[vmin, vmax])
| >>> pl.show()
|
| Compare B-spline interpolation to ``'hamming'``.
|
| >>> upsampled = knee.resample(2.0, 'hamming')
| >>> pl = image_plotter(upsampled, clim=[vmin, vmax])
| >>> pl.show()
|
| rfft(self, output_scalars_name=None, progress_bar: 'bool' = False)
| Apply a reverse fast Fourier transform (RFFT) to the active scalars.
|
| The input can be real or complex data, but the output is always
| :attr:`numpy.complex128`. The filter is fastest for images that have power
| of two sizes.
|
| The filter uses a butterfly diagram for each prime factor of the
| dimension. This makes images with prime number dimensions (i.e. 17x17)
| much slower to compute. FFTs of multidimensional meshes (i.e volumes)
| are decomposed so that each axis executes serially.
|
| The frequencies of the input assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with the applied reverse FFT.
|
| See Also
| --------
| fft : The direct transform.
| low_pass : Low-pass filtering of FFT output.
| high_pass : High-pass filtering of FFT output.
|
| Examples
| --------
| Apply reverse FFT to an example image.
|
| >>> from pyvista import examples
| >>> image = examples.download_moonlanding_image()
| >>> fft_image = image.fft()
| >>> image_again = fft_image.rfft()
| >>> image_again.point_data # doctest:+SKIP
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : PNGImage
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| PNGImage complex128 (298620,) SCALARS
|
| See :ref:`image_fft_example` for a full example using this filter.
|
| select_values(self: 'ImageData', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, fill_value: 'float | VectorLike[float]' = 0, replacement_value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, split: 'bool' = False)
| Select values of interest and fill the rest with a constant.
|
| Point or cell data may be selected with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to select a single label or groups
| of labels from categorical data, or to select multiple regions from continuous
| data. Selected values may optionally be split into separate meshes.
|
| The selected values are stored in an array with the same name as the input.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to select. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When selecting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to select. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| selection. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to select values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to select values less than or equal to zero.
|
| fill_value : float | VectorLike[float] | None, default: 0
| Value used to fill the image. Can be a single value or a multi-component
| vector. Non-selected parts of the image will have this value. Set this to
| ``None`` to keep the input array's original values for non-selected regions.
|
| replacement_value : float | VectorLike[float], optional
| Replacement value for the output array. Can be a single value or a
| multi-component vector. If provided, selected values will be replaced with
| the given value. If no value is given, the selected values are retained and
| returned as-is. Setting this value is useful for generating a binarized
| output array.
|
| scalars : str, optional
| Name of scalars to select from. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the selection. If ``True`` values are selected which do *not* have
| the specified values.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| selected independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain meshes with only the ``fill_value`` if no
| values meet the selection criteria.
|
| See Also
| --------
| image_threshold
| Similar filter for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Similar threshold-like filter for extracting values from any dataset.
| :meth:`~pyvista.DataSetFilters.split_values`
| Split a mesh by value into separate meshes.
| :meth:`~pyvista.DataSetFilters.threshold`
| Generalized thresholding filter which returns a :class:`~pyvista.UnstructuredGrid`.
|
| Returns
| -------
| output : pyvista.ImageData | pyvista.MultiBlock
| Image with selected values or a composite of meshes with selected
| values, depending on ``split``.
|
| Examples
| --------
| Load a CT image. Here we load
| :func:`~pyvista.examples.downloads.download_whole_body_ct_male`.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.download_whole_body_ct_male()
| >>> ct_image = dataset['ct']
|
| Show the initial data range.
|
| >>> ct_image.get_data_range()
| (np.int16(-1348), np.int16(3409))
|
| Select intensity values above ``150`` to select the bones.
|
| >>> bone_range = [150, float('inf')]
| >>> fill_value = -1000 # fill with intensity values corresponding to air
| >>> bone_image = ct_image.select_values(
| ... ranges=bone_range, fill_value=fill_value
| ... )
|
| Show the new data range.
|
| >>> bone_image.get_data_range()
| (np.int16(-1000), np.int16(3409))
|
| Plot the selected values. Use ``'foreground'`` opacity to make the fill value
| transparent and the selected values opaque.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_volume(
| ... bone_image,
| ... opacity='foreground',
| ... cmap='bone',
| ... )
| >>> pl.view_zx()
| >>> pl.camera.up = (0, 0, 1)
| >>> pl.show()
|
| Use ``'replacement_value'`` to binarize the selected values instead. The fill
| value, or background, is ``0`` by default.
|
| >>> bone_mask = ct_image.select_values(ranges=bone_range, replacement_value=1)
| >>> bone_mask.get_data_range()
| (np.int16(0), np.int16(1))
|
| Generate a surface contour of the mask and plot it.
|
| >>> surf = bone_mask.contour_labels()
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(surf, color=True)
| >>> pl.view_zx()
| >>> pl.camera.up = (0, 0, 1)
| >>> pl.show()
|
| Load a color image. Here we load :func:`~pyvista.examples.downloads.download_beach`.
|
| >>> image = examples.download_beach()
| >>> plot_kwargs = dict(
| ... cpos='xy', rgb=True, lighting=False, zoom='tight', show_axes=False
| ... )
| >>> image.plot(**plot_kwargs)
|
| Select components from the image which have a strong red component.
| Use ``replacement_value`` to replace these pixels with a pure red color
| and ``fill_value`` to fill the rest of the image with white pixels.
|
| >>> white = [255, 255, 255]
| >>> red = [255, 0, 0]
| >>> red_range = [200, 255]
| >>> red_component = 0
| >>> selected = image.select_values(
| ... ranges=red_range,
| ... component_mode=red_component,
| ... replacement_value=red,
| ... fill_value=white,
| ... )
|
| >>> selected.plot(**plot_kwargs)
|
| slice_index(self: 'ImageData', i: 'int | VectorLike[int] | slice | None' = None, j: 'int | VectorLike[int] | slice | None' = None, k: 'int | VectorLike[int] | slice | None' = None, *, index_mode: "Literal['extent', 'dimensions']" = 'dimensions', strict_index: 'bool' = False, rebase_coordinates: 'bool' = False, progress_bar: 'bool' = False) -> 'ImageData'
| Extract a subset using IJK indices.
|
| This filter enables slicing :class:`~pyvista.ImageData` with Python-style indexing using
| IJK coordinates. It can be used to extract a single slice, multiple contiguous slices, or
| a volume of interest. Unlike other slicing filters, this filter returns
| :class:`~pyvista.ImageData`.
|
| .. note::
| Slicing by index is also possible using the "get index" operator ``[]``. See examples.
|
| .. versionadded::0.46
|
| Parameters
| ----------
| i, j, k : int | VectorLike[int] | slice, optional
| Indices to slice along the I, J, and K coordinate axes, respectively. Specify an
| integer for a single index, or two integers ``[start, stop)`` for a range of indices.
|
| .. note::
|
| Like regular Python slicing:
|
| - Half-open intervals are used, i.e. the ``start`` index is included in the range
| but the ``stop`` index is not.
| - Negative indexing is supported.
| - An ``IndexError`` is raised when a single integer is specified as the index and
| the index is out-of-bounds.
| - An ``IndexError`` is `not` raised when a range is specified as the index and
| the index is out-of-bounds. This default can be overridden by setting
| ``strict_index=True``.
| - A copy of the data is returned (modifying the sliced output does `not` affect
| the input data).
|
| index_mode : 'extent' | 'dimensions', default: 'dimensions'
| Mode to use when determining the range of values to index from.
|
| - Use ``'dimensions'`` to index values in the range ``[0, dimensions - 1]``.
| - Use ``'extent'`` to index values based on the :class:`~pyvista.ImageData.extent`,
| i.e. ``[offset, offset + dimensions - 1]``.
|
| The main difference between these modes is the inclusion or exclusion of the
| :attr:`~pyvista.ImageData.offset`. ``dimensions`` is more pythonic and is how the
| object's data arrays themselves would be indexed, whereas ``'extent'`` respects VTK's
| definition of ``extent`` and considers the object's geometry.
|
| strict_index : bool, default: False
| Raise an ``IndexError`` if `any` of the indices are out of range. By default, an
| ``IndexError`` is only raised if a single integer index is out of range, but not when
| a range of indices are specified; set this to ``True`` to raise in error in both cases.
|
| rebase_coordinates : bool, default: False
| Rebase the coordinate reference of the extracted subset:
|
| - the :attr:`~pyvista.ImageData.origin` is set to the minimum bounds of the subset
| - the :attr:`~pyvista.ImageData.offset` is reset to ``(0, 0, 0)``
|
| The rebasing effectively applies a positive translation in world (XYZ) coordinates and
| a similar (i.e. inverse) negative translation in voxel (IJK) coordinates. As a result,
| the :attr:`~pyvista.DataSet.bounds` of the output are unchanged, but the coordinate
| reference frame is modified.
|
| Set this to ``False`` to leave the origin unmodified and keep the offset specified by
| the indexing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Sliced mesh.
|
| See Also
| --------
| crop
| extract_subset
| :meth:`~pyvista.DataObjectFilters.slice`
| :meth:`~pyvista.DataObjectFilters.slice_implicit`
| :meth:`~pyvista.DataObjectFilters.slice_orthogonal`
| :meth:`~pyvista.DataObjectFilters.slice_along_axis`
| :meth:`~pyvista.DataObjectFilters.slice_along_line`
|
| Examples
| --------
| Create a :class:`~pyvista.ImageData` mesh and give it some point data.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(10, 10, 10))
| >>> mesh['data'] = range(mesh.n_points)
|
| Extract a single slice along the k-axis.
|
| >>> sliced = mesh.slice_index(k=5)
| >>> sliced.dimensions
| (10, 10, 1)
|
| Equivalently:
|
| >>> sliced2 = mesh[:, :, 5]
| >>> sliced == sliced2
| True
|
| Extract a volume of interest.
|
| >>> sliced = mesh.slice_index(i=[1, 3], j=[2, 5], k=[5, 10])
| >>> sliced.dimensions
| (2, 3, 5)
|
| Equivalently:
|
| >>> sliced2 = mesh[1:3, 2:5, 5:10]
| >>> sliced == sliced2
| True
|
| Use ``None`` to implicitly define the start and/or stop indices.
|
| >>> sliced = mesh.slice_index(i=[None, 3], j=[2, None], k=None)
| >>> sliced.dimensions
| (3, 8, 10)
|
| Equivalently:
|
| >>> sliced2 = mesh[:3, 2:, :]
| >>> sliced == sliced2
| True
|
| See :ref:`slice_example` for more examples using this filter.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkImageData:
|
| AllocateScalars(...)
| AllocateScalars(self, dataType:int, numComponents:int) -> None
| C++: virtual void AllocateScalars(int dataType, int numComponents)
| AllocateScalars(self, pipeline_info:vtkInformation) -> None
| C++: virtual void AllocateScalars(vtkInformation *pipeline_info)
|
| Allocate the point scalars for this dataset. The data type
| determines the type of the array (VTK_FLOAT, VTK_INT etc.) where
| as numComponents determines its number of components.
|
| ApplyIndexToPhysicalMatrix(...)
| ApplyIndexToPhysicalMatrix(self, source:vtkMatrix4x4) -> None
| C++: void ApplyIndexToPhysicalMatrix(vtkMatrix4x4 *source)
|
| Set the transformation matrix from the index space to the
| physical space coordinate system of the dataset. The transform is
| a 4 by 4 matrix. The supplied matrix pointer is not stored in the
| the image object but the matrix values are used for updating the
| Origin, Spacing, and DirectionMatrix.
| \sa SetOrigin
| \sa SetSpacing
| \sa SetDirectionMatrix
|
| ApplyPhysicalToIndexMatrix(...)
| ApplyPhysicalToIndexMatrix(self, source:vtkMatrix4x4) -> None
| C++: void ApplyPhysicalToIndexMatrix(vtkMatrix4x4 *source)
|
| Get the transformation matrix from the physical space to the
| index space coordinate system of the dataset. The transform is a
| 4 by 4 matrix. The supplied matrix pointer is not stored in the
| the image object but the matrix values are used for updating the
| Origin, Spacing, and DirectionMatrix.
| \sa SetOrigin
| \sa SetSpacing
| \sa SetDirectionMatrix
|
| ComputeBounds(...)
| ComputeBounds(self) -> None
| C++: void ComputeBounds() override;
|
| Compute the data bounding box from data points. THIS METHOD IS
| NOT THREAD SAFE.
|
| ComputeCellId(...)
| ComputeCellId(self, ijk:[int, int, int]) -> int
| C++: vtkIdType ComputeCellId(int ijk[3]) override;
|
| Given a location in structured coordinates (i-j-k), return the
| cell id. Rely on vtkStructuredData::ComputeCellIdForExtent
|
| ComputeIndexToPhysicalMatrix(...)
| ComputeIndexToPhysicalMatrix(origin:(float, float, float),
| spacing:(float, float, float), direction:(float, float, float,
| float, float, float, float, float, float), result:[float,
| float, float, float, float, float, float, float, float, float,
| float, float, float, float, float, float]) -> None
| C++: static void ComputeIndexToPhysicalMatrix(
| double const origin[3], double const spacing[3],
| double const direction[9], double result[16])
|
| Static method to compute the IndexToPhysicalMatrix.
|
| ComputeInternalExtent(...)
| ComputeInternalExtent(self, intExt:[int, ...], tgtExt:[int, ...],
| bnds:[int, ...]) -> None
| C++: void ComputeInternalExtent(int *intExt, int *tgtExt,
| int *bnds)
|
| Given how many pixel are required on a side for boundary
| conditions (in bnds), the target extent to traverse, compute the
| internal extent (the extent for this ImageData that does not
| suffer from any boundary conditions) and place it in intExt
|
| ComputePhysicalToIndexMatrix(...)
| ComputePhysicalToIndexMatrix(origin:(float, float, float),
| spacing:(float, float, float), direction:(float, float, float,
| float, float, float, float, float, float), result:[float,
| float, float, float, float, float, float, float, float, float,
| float, float, float, float, float, float]) -> None
| C++: static void ComputePhysicalToIndexMatrix(
| double const origin[3], double const spacing[3],
| double const direction[9], double result[16])
|
| Static method to compute the PhysicalToIndexMatrix.
|
| ComputePointId(...)
| ComputePointId(self, ijk:[int, int, int]) -> int
| C++: vtkIdType ComputePointId(int ijk[3]) override;
|
| Given a location in structured coordinates (i-j-k), return the
| point id. Rely on vtkStructuredData::ComputePointIdForExtent
|
| ComputeStructuredCoordinates(...)
| ComputeStructuredCoordinates(self, x:(float, float, float),
| ijk:[int, int, int], pcoords:[float, float, float]) -> int
| C++: int ComputeStructuredCoordinates(const double x[3],
| int ijk[3], double pcoords[3]) override;
| ComputeStructuredCoordinates(self, x:(float, float, float),
| ijk:[int, int, int], pcoords:[float, float, float],
| tol2:float) -> int
| C++: virtual int ComputeStructuredCoordinates(const double x[3],
| int ijk[3], double pcoords[3], double tol2)
|
| Computes the structured coordinates for a point x[3]. The voxel
| is specified by the array ijk[3], and the parametric coordinates
| in the cell are specified with pcoords[3]. The function returns a
| 0 if the point x is outside of the volume, and a 1 if inside the
| volume, using squared tolerance tol2 (1e-12 if not provided).
|
| CopyAndCastFrom(...)
| CopyAndCastFrom(self, inData:vtkImageData, extent:[int, int, int,
| int, int, int]) -> None
| C++: virtual void CopyAndCastFrom(vtkImageData *inData,
| int extent[6])
| CopyAndCastFrom(self, inData:vtkImageData, x0:int, x1:int, y0:int,
| y1:int, z0:int, z1:int) -> None
| C++: virtual void CopyAndCastFrom(vtkImageData *inData, int x0,
| int x1, int y0, int y1, int z0, int z1)
|
| This method is passed a input and output region, and executes the
| filter algorithm to fill the output from the input. It just
| executes a switch statement to call the correct function for the
| regions data types.
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, information:vtkInformation)
| -> None
| C++: void CopyInformationFromPipeline(vtkInformation *information)
| override;
|
| Override these to handle origin, spacing, scalar type, and scalar
| number of components. See vtkDataObject for details.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, information:vtkInformation)
| -> None
| C++: void CopyInformationToPipeline(vtkInformation *information)
| override;
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect the image to
| a pipeline.
|
| CopyStructure(...)
| CopyStructure(self, ds:vtkDataSet) -> None
| C++: void CopyStructure(vtkDataSet *ds) override;
|
| Copy the geometric and topological structure of an input image
| data object.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: void Crop(const int *updateExtent) override;
|
| Reallocates and copies to set the Extent to updateExtent. This is
| used internally when the exact extent is requested, and the
| source generated more than the update extent.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| ExtendedNew(...)
| ExtendedNew() -> vtkImageData
| C++: static vtkImageData *ExtendedNew()
|
| FindCell(...)
| FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int,
| tol2:float, subId:int, pcoords:[float, float, float],
| weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
| FindCell(self, x:[float, float, float], cell:vtkCell,
| gencell:vtkGenericCell, cellId:int, tol2:float, subId:int,
| pcoords:[float, float, float], weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkGenericCell *gencell, vtkIdType cellId, double tol2,
| int &subId, double pcoords[3], double *weights) override;
|
| Locate cell based on global coordinate x and tolerance squared.
| If cell and cellId is non-nullptr, then search starts from this
| cell and looks at immediate neighbors. Returns cellId >= 0 if
| inside, < 0 otherwise. The parametric coordinates are provided
| in pcoords[3]. The interpolation weights are returned in
| weights[]. (The number of weights is equal to the number of
| points in the found cell). Tolerance is used to control how close
| the point is to be considered "in" the cell. THIS METHOD IS NOT
| THREAD SAFE.
|
| FindPoint(...)
| FindPoint(self, x:[float, float, float]) -> int
| C++: vtkIdType FindPoint(double x[3]) override;
| FindPoint(self, x:float, y:float, z:float) -> int
| C++: vtkIdType FindPoint(double x, double y, double z)
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated. The
| memory size returned is guaranteed to be greater than or equal to
| the memory required to represent the data (e.g., extra space in
| arrays, etc. are not included in the return value). THIS METHOD
| IS THREAD SAFE.
|
| GetArrayIncrements(...)
| GetArrayIncrements(self, array:vtkDataArray, increments:[int, int,
| int]) -> None
| C++: void GetArrayIncrements(vtkDataArray *array,
| vtkIdType increments[3])
|
| Since various arrays have different number of components, the
| will have different increments.
|
| GetArrayPointer(...)
| GetArrayPointer(self, array:vtkDataArray, coordinates:[int, int,
| int]) -> Pointer
| C++: void *GetArrayPointer(vtkDataArray *array,
| int coordinates[3])
| GetArrayPointer(self, array:vtkDataArray, x:int, y:int, z:int)
| -> Pointer
| C++: void *GetArrayPointer(vtkDataArray *array, int x, int y,
| int z)
|
| GetArrayPointerForExtent(...)
| GetArrayPointerForExtent(self, array:vtkDataArray, extent:[int,
| int, int, int, int, int]) -> Pointer
| C++: void *GetArrayPointerForExtent(vtkDataArray *array,
| int extent[6])
|
| These are convenience methods for getting a pointer from any
| filed array. It is a start at expanding image filters to process
| any array (not just scalars).
|
| GetAxisUpdateExtent(...)
| GetAxisUpdateExtent(self, axis:int, min:int, max:int,
| updateExtent:(int, ...)) -> None
| C++: virtual void GetAxisUpdateExtent(int axis, int &min,
| int &max, const int *updateExtent)
|
| GetCell(...)
| GetCell(self, cellId:int, cell:vtkGenericCell) -> None
| C++: void GetCell(vtkIdType cellId, vtkGenericCell *cell)
| override;
| GetCell(self, cellId:int) -> vtkCell
| C++: vtkCell *GetCell(vtkIdType cellId) override;
| GetCell(self, i:int, j:int, k:int) -> vtkCell
| C++: vtkCell *GetCell(int i, int j, int k) override;
|
| Standard vtkDataSet API methods. See vtkDataSet for more
| information.
|
| GetCellBounds(...)
| GetCellBounds(self, cellId:int, bounds:[float, float, float,
| float, float, float]) -> None
| C++: void GetCellBounds(vtkIdType cellId, double bounds[6])
| override;
|
| Get the bounds of the cell with cellId such that: 0 <= cellId <
| NumberOfCells. A subclass may be able to determine the bounds of
| cell without using an expensive GetCell() method. A default
| implementation is provided that actually uses a GetCell() call.
| This is to ensure the method is available to all datasets.
| Subclasses should override this method to provide an efficient
| implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetContinuousIncrements(...)
| GetContinuousIncrements(self, extent:[int, int, int, int, int,
| int], incX:int, incY:int, incZ:int) -> None
| C++: virtual void GetContinuousIncrements(int extent[6],
| vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ)
| GetContinuousIncrements(self, scalars:vtkDataArray, extent:[int,
| int, int, int, int, int], incX:int, incY:int, incZ:int)
| -> None
| C++: virtual void GetContinuousIncrements(vtkDataArray *scalars,
| int extent[6], vtkIdType &incX, vtkIdType &incY,
| vtkIdType &incZ)
|
| Different ways to get the increments for moving around the data.
| incX is always returned with 0. incY is returned with the
| increment needed to move from the end of one X scanline of data
| to the start of the next line. incZ is filled in with the
| increment needed to move from the end of one image to the start
| of the next. The proper way to use these values is to for a loop
| over Z, Y, X, C, incrementing the pointer by 1 after each
| component. When the end of the component is reached, the pointer
| is set to the beginning of the next pixel, thus incX is properly
| set to 0. The first form of GetContinuousIncrements uses the
| active scalar field while the second form allows the scalar array
| to be passed in.
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkImageData
| C++: static vtkImageData *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkImageData
| C++: static vtkImageData *GetData(vtkInformationVector *v,
| int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return what type of dataset this is.
|
| GetDirectionMatrix(...)
| GetDirectionMatrix(self) -> vtkMatrix3x3
| C++: virtual vtkMatrix3x3 *GetDirectionMatrix()
|
| Set/Get the direction transform of the dataset. The direction
| matrix is a 3x3 transformation matrix supporting scaling and
| rotation.
|
| GetIncrements(...)
| GetIncrements(self) -> (int, int, int)
| C++: virtual vtkIdType *GetIncrements()
| GetIncrements(self, incX:int, incY:int, incZ:int) -> None
| C++: virtual void GetIncrements(vtkIdType &incX, vtkIdType &incY,
| vtkIdType &incZ)
| GetIncrements(self, inc:[int, int, int]) -> None
| C++: virtual void GetIncrements(vtkIdType inc[3])
| GetIncrements(self, scalars:vtkDataArray) -> (int, int, int)
| C++: virtual vtkIdType *GetIncrements(vtkDataArray *scalars)
| GetIncrements(self, scalars:vtkDataArray, incX:int, incY:int,
| incZ:int) -> None
| C++: virtual void GetIncrements(vtkDataArray *scalars,
| vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ)
| GetIncrements(self, scalars:vtkDataArray, inc:[int, int, int])
| -> None
| C++: virtual void GetIncrements(vtkDataArray *scalars,
| vtkIdType inc[3])
|
| Different ways to get the increments for moving around the data.
| GetIncrements() calls ComputeIncrements() to ensure the
| increments are up to date. The first three methods compute the
| increments based on the active scalar field while the next three,
| the scalar field is passed in.
|
| Note that all methods which do not have the increments passed in
| are not thread-safe. When working on a given `vtkImageData`
| instance on multiple threads, each thread should use the `inc*`
| overloads to compute the increments to avoid racing with other
| threads.
|
| GetIndexToPhysicalMatrix(...)
| GetIndexToPhysicalMatrix(self) -> vtkMatrix4x4
| C++: virtual vtkMatrix4x4 *GetIndexToPhysicalMatrix()
|
| Get the transformation matrix from the index space to the
| physical space coordinate system of the dataset. The transform is
| a 4 by 4 matrix.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOrigin(...)
| GetOrigin(self) -> (float, float, float)
| C++: virtual double *GetOrigin()
|
| Set/Get the origin of the dataset. The origin is the position in
| world coordinates of the point of extent (0,0,0). This point does
| not have to be part of the dataset, in other words, the dataset
| extent does not have to start at (0,0,0) and the origin can be
| outside of the dataset bounding box. The origin plus spacing
| determine the position in space of the points.
|
| GetPhysicalToIndexMatrix(...)
| GetPhysicalToIndexMatrix(self) -> vtkMatrix4x4
| C++: virtual vtkMatrix4x4 *GetPhysicalToIndexMatrix()
|
| Get the transformation matrix from the physical space to the
| index space coordinate system of the dataset. The transform is a
| 4 by 4 matrix.
|
| GetPointGradient(...)
| GetPointGradient(self, i:int, j:int, k:int, s:vtkDataArray,
| g:[float, float, float]) -> None
| C++: virtual void GetPointGradient(int i, int j, int k,
| vtkDataArray *s, double g[3])
|
| Given structured coordinates (i,j,k) for a point in a structured
| point dataset, compute the gradient vector from the scalar data
| at that point. The scalars s are the scalars from which the
| gradient is to be computed. This method will treat structured
| point datasets of any dimension.
|
| GetScalarComponentAsDouble(...)
| GetScalarComponentAsDouble(self, x:int, y:int, z:int,
| component:int) -> float
| C++: virtual double GetScalarComponentAsDouble(int x, int y,
| int z, int component)
|
| GetScalarComponentAsFloat(...)
| GetScalarComponentAsFloat(self, x:int, y:int, z:int,
| component:int) -> float
| C++: virtual float GetScalarComponentAsFloat(int x, int y, int z,
| int component)
|
| For access to data from wrappers
|
| GetScalarIndex(...)
| GetScalarIndex(self, coordinates:[int, int, int]) -> int
| C++: virtual vtkIdType GetScalarIndex(int coordinates[3])
| GetScalarIndex(self, x:int, y:int, z:int) -> int
| C++: virtual vtkIdType GetScalarIndex(int x, int y, int z)
|
| GetScalarIndexForExtent(...)
| GetScalarIndexForExtent(self, extent:[int, int, int, int, int,
| int]) -> int
| C++: virtual vtkIdType GetScalarIndexForExtent(int extent[6])
|
| Access the index for the scalar data
|
| GetScalarPointer(...)
| GetScalarPointer(self, coordinates:[int, int, int]) -> Pointer
| C++: virtual void *GetScalarPointer(int coordinates[3])
| GetScalarPointer(self, x:int, y:int, z:int) -> Pointer
| C++: virtual void *GetScalarPointer(int x, int y, int z)
| GetScalarPointer(self) -> Pointer
| C++: virtual void *GetScalarPointer()
|
| GetScalarPointerForExtent(...)
| GetScalarPointerForExtent(self, extent:[int, int, int, int, int,
| int]) -> Pointer
| C++: virtual void *GetScalarPointerForExtent(int extent[6])
|
| Access the native pointer for the scalar data
|
| GetScalarSize(...)
| GetScalarSize(self, meta_data:vtkInformation) -> int
| C++: virtual int GetScalarSize(vtkInformation *meta_data)
| GetScalarSize(self) -> int
| C++: virtual int GetScalarSize()
|
| Get the size of the scalar type in bytes.
|
| GetScalarTypeMax(...)
| GetScalarTypeMax(self, meta_data:vtkInformation) -> float
| C++: virtual double GetScalarTypeMax(vtkInformation *meta_data)
| GetScalarTypeMax(self) -> float
| C++: virtual double GetScalarTypeMax()
|
| GetScalarTypeMin(...)
| GetScalarTypeMin(self, meta_data:vtkInformation) -> float
| C++: virtual double GetScalarTypeMin(vtkInformation *meta_data)
| GetScalarTypeMin(self) -> float
| C++: virtual double GetScalarTypeMin()
|
| These returns the minimum and maximum values the ScalarType can
| hold without overflowing.
|
| GetSpacing(...)
| GetSpacing(self) -> (float, float, float)
| C++: virtual double *GetSpacing()
|
| Set the spacing (width,height,length) of the cubical cells that
| compose the data set.
|
| GetVoxelGradient(...)
| GetVoxelGradient(self, i:int, j:int, k:int, s:vtkDataArray,
| g:vtkDataArray) -> None
| C++: virtual void GetVoxelGradient(int i, int j, int k,
| vtkDataArray *s, vtkDataArray *g)
|
| Given structured coordinates (i,j,k) for a voxel cell, compute
| the eight gradient values for the voxel corners. The order in
| which the gradient vectors are arranged corresponds to the
| ordering of the voxel points. Gradient vector is computed by
| central differences (except on edges of volume where forward
| difference is used). The scalars s are the scalars from which the
| gradient is to be computed. This method will treat only 3D
| structured point datasets (i.e., volumes).
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkImageData
| C++: vtkImageData *NewInstance()
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: void PrepareForNewData() override;
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for image data we leave the
| old data in case the memory can be reused.
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkImageData
| C++: static vtkImageData *SafeDownCast(vtkObjectBase *o)
|
| SetAxisUpdateExtent(...)
| SetAxisUpdateExtent(self, axis:int, min:int, max:int,
| updateExtent:(int, ...), axisUpdateExtent:[int, ...]) -> None
| C++: virtual void SetAxisUpdateExtent(int axis, int min, int max,
| const int *updateExtent, int *axisUpdateExtent)
|
| Set / Get the extent on just one axis
|
| SetDirectionMatrix(...)
| SetDirectionMatrix(self, m:vtkMatrix3x3) -> None
| C++: virtual void SetDirectionMatrix(vtkMatrix3x3 *m)
| SetDirectionMatrix(self, elements:(float, float, float, float,
| float, float, float, float, float)) -> None
| C++: virtual void SetDirectionMatrix(const double elements[9])
| SetDirectionMatrix(self, e00:float, e01:float, e02:float,
| e10:float, e11:float, e12:float, e20:float, e21:float,
| e22:float) -> None
| C++: virtual void SetDirectionMatrix(double e00, double e01,
| double e02, double e10, double e11, double e12, double e20,
| double e21, double e22)
|
| SetOrigin(...)
| SetOrigin(self, i:float, j:float, k:float) -> None
| C++: virtual void SetOrigin(double i, double j, double k)
| SetOrigin(self, ijk:(float, float, float)) -> None
| C++: virtual void SetOrigin(const double ijk[3])
|
| SetScalarComponentFromDouble(...)
| SetScalarComponentFromDouble(self, x:int, y:int, z:int,
| component:int, v:float) -> None
| C++: virtual void SetScalarComponentFromDouble(int x, int y,
| int z, int component, double v)
|
| SetScalarComponentFromFloat(...)
| SetScalarComponentFromFloat(self, x:int, y:int, z:int,
| component:int, v:float) -> None
| C++: virtual void SetScalarComponentFromFloat(int x, int y, int z,
| int component, float v)
|
| SetSpacing(...)
| SetSpacing(self, i:float, j:float, k:float) -> None
| C++: virtual void SetSpacing(double i, double j, double k)
| SetSpacing(self, ijk:(float, float, float)) -> None
| C++: virtual void SetSpacing(const double ijk[3])
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| TransformContinuousIndexToPhysicalPoint(...)
| TransformContinuousIndexToPhysicalPoint(self, i:float, j:float,
| k:float, xyz:[float, float, float]) -> None
| C++: virtual void TransformContinuousIndexToPhysicalPoint(
| double i, double j, double k, double xyz[3])
| TransformContinuousIndexToPhysicalPoint(self, ijk:(float, float,
| float), xyz:[float, float, float]) -> None
| C++: virtual void TransformContinuousIndexToPhysicalPoint(
| const double ijk[3], double xyz[3])
| TransformContinuousIndexToPhysicalPoint(i:float, j:float, k:float,
| origin:(float, float, float), spacing:(float, float, float),
| direction:(float, float, float, float, float, float, float,
| float, float), xyz:[float, float, float]) -> None
| C++: static void TransformContinuousIndexToPhysicalPoint(double i,
| double j, double k, double const origin[3],
| double const spacing[3], double const direction[9],
| double xyz[3])
|
| Convert coordinates from index space (ijk) to physical space
| (xyz).
|
| TransformIndexToPhysicalPoint(...)
| TransformIndexToPhysicalPoint(self, i:int, j:int, k:int,
| xyz:[float, float, float]) -> None
| C++: virtual void TransformIndexToPhysicalPoint(int i, int j,
| int k, double xyz[3])
| TransformIndexToPhysicalPoint(self, ijk:(int, int, int),
| xyz:[float, float, float]) -> None
| C++: virtual void TransformIndexToPhysicalPoint(const int ijk[3],
| double xyz[3])
|
| TransformPhysicalNormalToContinuousIndex(...)
| TransformPhysicalNormalToContinuousIndex(self, xyz:(float, float,
| float), ijk:[float, float, float]) -> None
| C++: virtual void TransformPhysicalNormalToContinuousIndex(
| const double xyz[3], double ijk[3])
|
| Convert normal from physical space (xyz) to index space (ijk).
|
| TransformPhysicalPlaneToContinuousIndex(...)
| TransformPhysicalPlaneToContinuousIndex(self, pplane:(float,
| float, float, float), iplane:[float, float, float, float])
| -> None
| C++: virtual void TransformPhysicalPlaneToContinuousIndex(
| double const pplane[4], double iplane[4])
|
| Convert a plane from physical to a continuous index. The plane is
| represented as n(x-xo)=0; or using a four component normal:
| pplane=( nx,ny,nz,-(n(x0)) ).
|
| TransformPhysicalPointToContinuousIndex(...)
| TransformPhysicalPointToContinuousIndex(self, x:float, y:float,
| z:float, ijk:[float, float, float]) -> None
| C++: virtual void TransformPhysicalPointToContinuousIndex(
| double x, double y, double z, double ijk[3])
| TransformPhysicalPointToContinuousIndex(self, xyz:(float, float,
| float), ijk:[float, float, float]) -> None
| C++: virtual void TransformPhysicalPointToContinuousIndex(
| const double xyz[3], double ijk[3])
|
| Convert coordinates from physical space (xyz) to index space
| (ijk).
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkImageData:
|
| __this__
| Pointer to the C++ object.
|
| data_object_type
| read-only, calls GetDataObjectType
|
| increments
| read-only, calls GetIncrements
|
| scalar_pointer
| read-only, calls GetScalarPointer
|
| scalar_size
| read-only, calls GetScalarSize
|
| scalar_type_max
| read-only, calls GetScalarTypeMax
|
| scalar_type_min
| read-only, calls GetScalarTypeMin
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkImageData:
|
| __vtkname__ = 'vtkImageData'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkCartesianGrid:
|
| BlankCell(...)
| BlankCell(self, ptId:int) -> None
| C++: virtual void BlankCell(vtkIdType ptId)
| BlankCell(self, i:int, j:int, k:int) -> None
| C++: virtual void BlankCell(int i, int j, int k)
|
| Methods for supporting blanking of cells. Blanking turns on or
| off cells in the structured grid. These methods should be called
| only after the dimensions of the grid are set.
|
| BlankPoint(...)
| BlankPoint(self, ptId:int) -> None
| C++: virtual void BlankPoint(vtkIdType ptId)
| BlankPoint(self, i:int, j:int, k:int) -> None
| C++: virtual void BlankPoint(int i, int j, int k)
|
| Methods for supporting blanking of cells. Blanking turns on or
| off points in the structured grid, and hence the cells connected
| to them. These methods should be called only after the dimensions
| of the grid are set.
|
| FindAndGetCell(...)
| FindAndGetCell(self, x:[float, float, float], cell:vtkCell,
| cellId:int, tol2:float, subId:int, pcoords:[float, float,
| float], weights:[float, ...]) -> vtkCell
| C++: vtkCell *FindAndGetCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
|
| Locate the cell that contains a point and return the cell. Also
| returns the subcell id, parametric coordinates and weights for
| subsequent interpolation. This method combines the derived class
| methods int FindCell and vtkCell *GetCell. Derived classes may
| provide a more efficient implementation. See for example
| vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE.
|
| GetCellDims(...)
| GetCellDims(self, cellDims:[int, int, int]) -> None
| C++: void GetCellDims(int cellDims[3])
|
| Given the node dimensions of this grid instance, this method
| computes the node dimensions. The value in each dimension can
| will have a lowest value of "1" such that computing the total
| number of cells can be achieved by simply by
| cellDims[0]*cellDims[1]*cellDims[2].
|
| GetCellNeighbors(...)
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds) override;
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList, seedLoc:[int, ...]) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds, int *seedLoc)
|
| Topological inquiry to get all cells using list of points
| exclusive of cell specified (e.g., cellId). Note that the list
| consists of only cells that use ALL the points provided. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetCellPoints(...)
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...),
| ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts, vtkIdList *ptIds) override;
| GetCellPoints(self, cellId:int, ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
| override;
|
| Topological inquiry to get points defining cell.
|
| This function MAY use ptIds, which is an object that is created
| by each thread, to guarantee thread safety.
|
| @warning Subsequent calls to this method may invalidate previous
| call
| results.
|
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetCellSize(...)
| GetCellSize(self, cellId:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType cellId) override;
|
| Get the size of cell with cellId such that: 0 <= cellId <
| NumberOfCells. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| @warning This method MUST be overridden for performance reasons.
| Default implementation is very inefficient.
|
| GetCellType(...)
| GetCellType(self, cellId:int) -> int
| C++: int GetCellType(vtkIdType cellId) override;
|
| Get type of cell with cellId such that: 0 <= cellId <
| NumberOfCells. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetCellTypes(...)
| GetCellTypes(self) -> vtkConstantArray_IhE
| C++: vtkConstantArray<unsigned char> *GetCellTypes()
| GetCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetCellTypes(vtkCellTypes *types)
|
| GetCellTypesArray(...)
| GetCellTypesArray(self) -> vtkConstantArray_IiE
| C++: vtkConstantArray<int> *GetCellTypesArray()
|
| GetCells(...)
| GetCells(self) -> vtkStructuredCellArray
| C++: vtkStructuredCellArray *GetCells()
|
| Return the image data connectivity array.
|
| NOTE: the returned object should not be modified.
|
| GetDataDescription(...)
| GetDataDescription(self) -> int
| C++: virtual int GetDataDescription()
|
| Get the data description of the rectilinear grid.
|
| GetDataDimension(...)
| GetDataDimension(self) -> int
| C++: int GetDataDimension()
|
| Return the dimensionality of the data.
|
| GetDimensions(...)
| GetDimensions(self) -> (int, int, int)
| C++: int *GetDimensions()
| GetDimensions(self, dims:[int, int, int]) -> None
| C++: void GetDimensions(int dims[3])
| GetDimensions(self, dims:[int, int, int]) -> None
| C++: void GetDimensions(vtkIdType dims[3])
|
| Get dimensions of this structured points dataset. It is the
| number of points on each axis. Dimensions are computed from
| Extents during this call.
| \warning Non thread-safe, use second signature if you want it to
| be.
|
| GetExtent(...)
| GetExtent(self) -> (int, int, int, int, int, int)
| C++: virtual int *GetExtent()
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: int GetExtentType() override;
|
| Structured extent. The extent type is a 3D extent
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Convenience method returns largest cell size in dataset. This is
| generally used to allocate memory for supporting data structures.
| THIS METHOD IS THREAD SAFE
|
| GetMaxSpatialDimension(...)
| GetMaxSpatialDimension(self) -> int
| C++: int GetMaxSpatialDimension() override;
|
| Get the maximum/minimum spatial dimensionality of the data which
| is the maximum/minimum dimension of all cells.
|
| @warning This method MUST be overridden for performance reasons.
| Default implementation is very inefficient.
|
| GetMinSpatialDimension(...)
| GetMinSpatialDimension(self) -> int
| C++: int GetMinSpatialDimension() override;
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| Determine the number of cells composing the dataset. THIS METHOD
| IS THREAD SAFE
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| Determine the number of points composing the dataset. THIS METHOD
| IS THREAD SAFE
|
| GetNumberOfScalarComponents(...)
| GetNumberOfScalarComponents(meta_data:vtkInformation) -> int
| C++: static int GetNumberOfScalarComponents(
| vtkInformation *meta_data)
| GetNumberOfScalarComponents(self) -> int
| C++: int GetNumberOfScalarComponents()
|
| GetPoint(...)
| GetPoint(self, id:int, x:[float, float, float]) -> None
| C++: void GetPoint(vtkIdType id, double x[3]) override;
| GetPoint(self, ptId:int) -> (float, float, float)
| C++: double *GetPoint(vtkIdType ptId) override;
|
| Copy point coordinates into user provided array x[3] for
| specified point id. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetPointCells(...)
| GetPointCells(self, ptId:int, cellIds:vtkIdList) -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
| override;
|
| Topological inquiry to get cells using point. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints() override;
|
| Standard vtkDataSet API methods. See vtkDataSet for more
| information.
|
| GetScalarType(...)
| GetScalarType(meta_data:vtkInformation) -> int
| C++: static int GetScalarType(vtkInformation *meta_data)
| GetScalarType(self) -> int
| C++: int GetScalarType()
|
| GetScalarTypeAsString(...)
| GetScalarTypeAsString(self) -> str
| C++: const char *GetScalarTypeAsString()
|
| GetTupleIndex(...)
| GetTupleIndex(self, array:vtkDataArray, coordinates:[int, int,
| int]) -> int
| C++: vtkIdType GetTupleIndex(vtkDataArray *array,
| int coordinates[3])
| GetTupleIndex(self, array:vtkDataArray, x:int, y:int, z:int)
| -> int
| C++: vtkIdType GetTupleIndex(vtkDataArray *array, int x, int y,
| int z)
|
| GetTupleIndexForExtent(...)
| GetTupleIndexForExtent(self, array:vtkDataArray, extent:[int, int,
| int, int, int, int]) -> int
| C++: vtkIdType GetTupleIndexForExtent(vtkDataArray *array,
| int extent[6])
|
| Given a data array and a coordinate, return the index of the
| tuple in the array corresponding to that coordinate.
|
| GetValueIndex(...)
| GetValueIndex(self, array:vtkDataArray, coordinates:[int, int,
| int]) -> int
| C++: vtkIdType GetValueIndex(vtkDataArray *array,
| int coordinates[3])
| GetValueIndex(self, array:vtkDataArray, x:int, y:int, z:int)
| -> int
| C++: vtkIdType GetValueIndex(vtkDataArray *array, int x, int y,
| int z)
|
| GetValueIndexForExtent(...)
| GetValueIndexForExtent(self, array:vtkDataArray, extent:[int, int,
| int, int, int, int]) -> int
| C++: vtkIdType GetValueIndexForExtent(vtkDataArray *array,
| int extent[6])
|
| Given a data array and a coordinate, return the index of the
| value in the array corresponding to that coordinate, considering
| the number of components.
|
| HasAnyBlankCells(...)
| HasAnyBlankCells(self) -> bool
| C++: bool HasAnyBlankCells() override;
|
| Returns 1 if there are any blanking cells 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyBlankPoints(...)
| HasAnyBlankPoints(self) -> bool
| C++: bool HasAnyBlankPoints() override;
|
| Returns 1 if there are any blanking points 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasNumberOfScalarComponents(...)
| HasNumberOfScalarComponents(meta_data:vtkInformation) -> bool
| C++: static bool HasNumberOfScalarComponents(
| vtkInformation *meta_data)
|
| HasScalarType(...)
| HasScalarType(meta_data:vtkInformation) -> bool
| C++: static bool HasScalarType(vtkInformation *meta_data)
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Restore data object to initial state. THIS METHOD IS NOT THREAD
| SAFE.
|
| IsCellVisible(...)
| IsCellVisible(self, cellId:int) -> int
| C++: unsigned char IsCellVisible(vtkIdType cellId)
|
| Return non-zero value if specified point is visible. These
| methods should be called only after the dimensions of the grid
| are set.
|
| IsPointVisible(...)
| IsPointVisible(self, ptId:int) -> int
| C++: unsigned char IsPointVisible(vtkIdType ptId)
|
| Return non-zero value if specified point is visible. These
| methods should be called only after the dimensions of the grid
| are set.
|
| SetDimensions(...)
| SetDimensions(self, i:int, j:int, k:int) -> None
| C++: void SetDimensions(int i, int j, int k)
| SetDimensions(self, dim:(int, int, int)) -> None
| C++: void SetDimensions(const int dim[3])
|
| Set dimensions of rectilinear grid dataset. This also sets the
| extent.
|
| SetExtent(...)
| SetExtent(self, extent:[int, int, int, int, int, int]) -> None
| C++: void SetExtent(int extent[6])
| SetExtent(self, xMin:int, xMax:int, yMin:int, yMax:int, zMin:int,
| zMax:int) -> None
| C++: void SetExtent(int xMin, int xMax, int yMin, int yMax,
| int zMin, int zMax)
|
| Set/Get the extent. On each axis, the extent is defined by the
| index of the first point and the index of the last point. The
| extent should be set before the "Scalars" are set or allocated.
| The Extent is stored in the order (X, Y, Z). The dataset extent
| does not have to start at (0,0,0). (0,0,0) is just the extent of
| the origin. The first point (the one with Id=0) is at extent
| (Extent[0],Extent[2],Extent[4]). As for any dataset, a data array
| on point data starts at Id=0.
|
| SetNumberOfScalarComponents(...)
| SetNumberOfScalarComponents(n:int, meta_data:vtkInformation)
| -> None
| C++: static void SetNumberOfScalarComponents(int n,
| vtkInformation *meta_data)
|
| Set/Get the number of scalar components for points. As with the
| SetScalarType method this is setting pipeline info. 1 if not set
| or empty.
|
| SetScalarType(...)
| SetScalarType(__a:int, meta_data:vtkInformation) -> None
| C++: static void SetScalarType(int, vtkInformation *meta_data)
|
| Set/Get the scalar data type for the points. This is setting
| pipeline info. Assume VTK_DOUBLE if not set or empty.
|
| UnBlankCell(...)
| UnBlankCell(self, ptId:int) -> None
| C++: virtual void UnBlankCell(vtkIdType ptId)
| UnBlankCell(self, i:int, j:int, k:int) -> None
| C++: virtual void UnBlankCell(int i, int j, int k)
|
| UnBlankPoint(...)
| UnBlankPoint(self, ptId:int) -> None
| C++: virtual void UnBlankPoint(vtkIdType ptId)
| UnBlankPoint(self, i:int, j:int, k:int) -> None
| C++: virtual void UnBlankPoint(int i, int j, int k)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkCartesianGrid:
|
| cell_types
| read-only, calls GetCellTypes
|
| cell_types_array
| read-only, calls GetCellTypesArray
|
| cells
| read-only, calls GetCells
|
| data_description
| read-only, calls GetDataDescription
|
| data_dimension
| read-only, calls GetDataDimension
|
| extent_type
| read-only, calls GetExtentType
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| max_spatial_dimension
| read-only, calls GetMaxSpatialDimension
|
| min_spatial_dimension
| read-only, calls GetMinSpatialDimension
|
| number_of_scalar_components
| read-only, calls GetNumberOfScalarComponents
|
| scalar_type
| read-only, calls GetScalarType
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| AllocateCellGhostArray(...)
| AllocateCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocateCellGhostArray()
|
| Allocate ghost array for cells.
|
| AllocatePointGhostArray(...)
| AllocatePointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocatePointGhostArray()
|
| Allocate ghost array for points.
|
| CheckAttributes(...)
| CheckAttributes(self) -> int
| C++: int CheckAttributes()
|
| This method checks to see if the cell and point attributes match
| the geometry. Many filters will crash if the number of tuples in
| an array is less than the number of points/cells. This method
| returns 1 if there is a mismatch, and 0 if everything is ok. It
| prints an error if an array is too short, and a warning if an
| array is too long.
|
| CopyAttributes(...)
| CopyAttributes(self, ds:vtkDataSet) -> None
| C++: virtual void CopyAttributes(vtkDataSet *ds)
|
| Copy the attributes associated with the specified dataset to this
| instance of vtkDataSet. THIS METHOD IS NOT THREAD SAFE.
|
| GenerateGhostArray(...)
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int])
| -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6])
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int],
| cellOnly:bool) -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6],
| bool cellOnly)
|
| Normally called by pipeline executives or algorithms only. This
| method computes the ghost arrays for a given dataset. The zeroExt
| argument specifies the extent of the region which ghost type = 0.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return a pointer to the geometry bounding box in the form
| (xmin,xmax, ymin,ymax, zmin,zmax). THIS METHOD IS NOT THREAD
| SAFE.
|
| GetCellData(...)
| GetCellData(self) -> vtkCellData
| C++: vtkCellData *GetCellData()
|
| Return a pointer to this dataset's cell data. THIS METHOD IS
| THREAD SAFE
|
| GetCellGhostArray(...)
| GetCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellGhostArray()
|
| Get the array that defines the ghost type of each cell. We cache
| the pointer to the array to save a lookup involving string
| comparisons
|
| GetCellNumberOfFaces(...)
| GetCellNumberOfFaces(self, cellId:int, cellType:int,
| cell:vtkGenericCell) -> int
| C++: virtual int GetCellNumberOfFaces(vtkIdType cellId,
| unsigned char &cellType, vtkGenericCell *cell)
|
| Get the number of faces of a cell.
|
| Most of the times extracting the number of faces requires only
| extracting the cell type. However, for some cell types, the
| number of faces is not constant. For example, a convex point set
| cell can have a different number of faces for each cell. That's
| why this method requires the cell id and the dataset.
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: double *GetCenter()
| GetCenter(self, center:[float, float, float]) -> None
| C++: void GetCenter(double center[3])
|
| Get the center of the bounding box. THIS METHOD IS NOT THREAD
| SAFE.
|
| GetDistinctCellTypes(...)
| GetDistinctCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetDistinctCellTypes(vtkCellTypes *types)
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset 5 triangles, 3 lines, and
| 100 hexahedra would result a list of three entries, corresponding
| to the types VTK_TRIANGLE, VTK_LINE, and VTK_HEXAHEDRON. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetGhostArray(int type) override;
|
| Returns the ghost array for the given type (point or cell). Takes
| advantage of the cache with the pointer to the array to save a
| string comparison.
|
| GetLength(...)
| GetLength(self) -> float
| C++: double GetLength()
|
| Return the length of the diagonal of the bounding box. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Return the squared length of the diagonal of the bounding box.
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Datasets are composite objects and need to check each part for
| MTime THIS METHOD IS THREAD SAFE
|
| GetMeshMTime(...)
| GetMeshMTime(self) -> int
| C++: virtual vtkMTimeType GetMeshMTime()
|
| Abstract method which return the mesh (geometry/topology)
| modification time. This time is different from the usual MTime
| which also takes into account the modification of data arrays.
| This function can be used to track the changes on the mesh
| separately from the data arrays (eg. static mesh over time with
| transient data). The default implementation returns the MTime. It
| is up to subclasses to provide a better approach.
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| GetPointData(...)
| GetPointData(self) -> vtkPointData
| C++: vtkPointData *GetPointData()
|
| Return a pointer to this dataset's point data. THIS METHOD IS
| THREAD SAFE
|
| GetPointGhostArray(...)
| GetPointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetPointGhostArray()
|
| Gets the array that defines the ghost type of each point. We
| cache the pointer to the array to save a lookup involving string
| comparisons
|
| GetScalarRange(...)
| GetScalarRange(self, range:[float, float]) -> None
| C++: virtual void GetScalarRange(double range[2])
| GetScalarRange(self) -> (float, float)
| C++: double *GetScalarRange()
|
| Convenience method to get the range of the first component (and
| only the first component) of any scalars in the data set. If the
| data has both point data and cell data, it returns the (min/max)
| range of combined point and cell data. If there are no point or
| cell scalars the method will return (0,1). Note: It might be
| necessary to call Update to create or refresh the scalars before
| calling this method. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| HasAnyGhostCells(...)
| HasAnyGhostCells(self) -> bool
| C++: bool HasAnyGhostCells()
|
| Returns 1 if there are any ghost cells 0 otherwise.
|
| HasAnyGhostPoints(...)
| HasAnyGhostPoints(self) -> bool
| C++: bool HasAnyGhostPoints()
|
| Returns 1 if there are any ghost points 0 otherwise.
|
| NewCellIterator(...)
| NewCellIterator(self) -> vtkCellIterator
| C++: virtual vtkCellIterator *NewCellIterator()
|
| Return an iterator that traverses the cells in this data set.
|
| SetCellOrderAndRationalWeights(...)
| SetCellOrderAndRationalWeights(self, cellId:int,
| cell:vtkGenericCell) -> None
| C++: void SetCellOrderAndRationalWeights(vtkIdType cellId,
| vtkGenericCell *cell)
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: virtual void Squeeze()
|
| Reclaim any extra memory used to store data. THIS METHOD IS NOT
| THREAD SAFE.
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| cell_ghost_array
| read-only, calls GetCellGhostArray
|
| length2
| read-only, calls GetLength2
|
| m_time
| read-only, calls GetMTime
|
| mesh_m_time
| read-only, calls GetMeshMTime
|
| point_ghost_array
| read-only, calls GetPointGhostArray
|
| scalar_range
| read-only, calls GetScalarRange
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| CELL_DATA_FIELD = 2
|
| DATA_OBJECT_FIELD = 0
|
| FieldDataType = <class 'vtkmodules.vtkCommonDataModel.vtkDataSet.Field...
|
| POINT_DATA_FIELD = 1
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.ImageDataFilters
Python Library Documentation: class ImageDataFilters in module pyvista.core.filters.image_data
class ImageDataFilters(pyvista.core.filters.data_set.DataSetFilters)
| ImageDataFilters(*args, **kwargs)
|
| An internal class to manage filters/algorithms for uniform grid datasets.
|
| Method resolution order:
| ImageDataFilters
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| builtins.object
|
| Methods defined here:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| cells_to_points(self: 'ImageData', scalars: 'str | None' = None, *, dimensionality: "VectorLike[bool] | Literal[0, 1, 2, 3, '0D', '1D', '2D', '3D', 'preserve']" = 'preserve', copy: 'bool' = True)
| Re-mesh image data from a cell-based to a point-based representation.
|
| This filter changes how image data is represented. Data represented as cells
| at the input is re-meshed into an alternative representation as points at the
| output. Only the :class:`~pyvista.ImageData` container is modified so that
| the number of input cells equals the number of output points. The re-meshing is
| otherwise lossless in the sense that cell data at the input is passed through
| unmodified and stored as point data at the output. Any point data at the input is
| ignored and is not used by this filter.
|
| To change the image data's representation, the input cell centers are used to
| represent the output points. This has the effect of "shrinking" the
| input image dimensions by one along each axis (i.e. half the cell width on each
| side). For example, an image with 101 points and 100 cells along an axis at the
| input will have 100 points and 99 cells at the output. If the input has 1mm
| spacing, the axis size will also decrease from 100mm to 99mm.
|
| Since filters may be inherently cell-based (e.g. some :class:`~pyvista.DataSetFilters`)
| or may operate on point data exclusively (e.g. most :class:`~pyvista.ImageDataFilters`),
| re-meshing enables the same data to be used with either kind of filter while
| ensuring the input data to those filters has the appropriate representation.
| This filter is also useful when plotting image data to achieve a desired visual
| effect, such as plotting images as points instead of as voxel cells.
|
| .. note::
| Only the input's :attr:`~pyvista.ImageData.dimensions`, and
| :attr:`~pyvista.ImageData.origin` are modified by this filter. Other spatial
| properties such as :attr:`~pyvista.ImageData.spacing` and
| :attr:`~pyvista.ImageData.direction_matrix` are not affected.
|
| .. versionadded:: 0.44.0
|
| See Also
| --------
| points_to_cells
| Inverse of this filter to represent points as cells.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample cell data as point data without modifying the container.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample point data as cell data without modifying the container.
|
| Parameters
| ----------
| scalars : str, optional
| Name of cell data scalars to pass through to the output as point data. Use
| this parameter to restrict the output to only include the specified array.
| By default, all cell data arrays at the input are passed through as point
| data at the output.
|
| dimensionality : VectorLike[bool], Literal[0, 1, 2, 3, "0D", "1D", "2D", "3D", "preserve"]
| Control which dimensions will be modified by the filter.
| ``'preserve'`` is used by default.
|
| - Can be specified as a sequence of 3 boolean to allow modification on a per
| dimension basis.
| - ``0`` or ``'0D'``: convenience alias to output a 0D ImageData with
| dimensions ``(1, 1, 1)``. Only valid for 0D inputs.
| - ``1`` or ``'1D'``: convenience alias to output a 1D ImageData where
| exactly one dimension is greater than one, e.g. ``(>1, 1, 1)``. Only valid
| for 0D or 1D inputs.
| - ``2`` or ``'2D'``: convenience alias to output a 2D ImageData where
| exactly two dimensions are greater than one, e.g. ``(>1, >1, 1)``. Only
| valid for 0D, 1D, or 2D inputs.
| - ``3`` or ``'3D'``: convenience alias to output a 3D ImageData, where all
| three dimensions are greater than one, e.g. ``(>1, >1, >1)``. Valid for
| any 0D, 1D, 2D, or 3D inputs.
| - ``'preserve'`` (default): convenience alias to not modify singleton
| dimensions.
|
| .. note::
| This filter does not modify singleton dimensions with ``dimensionality``
| set as ``'preserve'`` by default.
|
| copy : bool, default: True
| Copy the input cell data before associating it with the output point data.
| If ``False``, the input and output will both refer to the same data array(s).
|
| Returns
| -------
| pyvista.ImageData
| Image with a point-based representation.
|
| Examples
| --------
| Load an image with cell data.
|
| >>> from pyvista import examples
| >>> image = examples.load_uniform()
|
| Show the current properties and cell arrays of the image.
|
| >>> image
| ImageData (...)
| N Cells: 729
| N Points: 1000
| X Bounds: 0.000e+00, 9.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| Dimensions: 10, 10, 10
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 2
|
| >>> image.cell_data.keys()
| ['Spatial Cell Data']
|
| Re-mesh the cells and cell data as points and point data.
|
| >>> points_image = image.cells_to_points()
|
| Show the properties and point arrays of the re-meshed image.
|
| >>> points_image
| ImageData (...)
| N Cells: 512
| N Points: 729
| X Bounds: 5.000e-01, 8.500e+00
| Y Bounds: 5.000e-01, 8.500e+00
| Z Bounds: 5.000e-01, 8.500e+00
| Dimensions: 9, 9, 9
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> points_image.point_data.keys()
| ['Spatial Cell Data']
|
| Observe that:
|
| - The input cell array is now a point array
| - The output has one less array (the input point data is ignored)
| - The dimensions have decreased by one
| - The bounds have decreased by half the spacing
| - The output ``N Points`` equals the input ``N Cells``
|
| See :ref:`image_representations_example` for more examples using this filter.
|
| close(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Perform morphological closing on continuous or binary data.
|
| Closing is a :meth:`dilation <dilate>` followed by an :meth:`erosion <erode>`.
| It is used to fill small holes/gaps while preserving the shape and size of larger objects.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are closed, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary closing or continuous closing is used. Refer to
| :meth:`dilate` and/or :meth:`erode` for details about using this keyword.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been closed.
|
| See Also
| --------
| open, erode, dilate
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| Load a binary image: :func:`~pyvista.examples.downloads.download_yinyang()`.
|
| >>> from pyvista import examples
| >>> im = examples.download_yinyang()
|
| Use ``close`` with a relatively small kernel to fill the top black edge of the yinyang.
|
| >>> closed = im.close(kernel_size=5)
| >>> kwargs = dict(
| ... cmap='grey',
| ... lighting=False,
| ... cpos='xy',
| ... zoom='tight',
| ... show_axes=False,
| ... show_scalar_bar=False,
| ... )
| >>> closed.plot(**kwargs)
|
| Use a much larger kernel to also fill the small black circle.
|
| >>> closed = im.close(kernel_size=25)
| >>> closed.plot(**kwargs)
|
| Since closing is the inverse of opening, we can alternatively use :meth:`open` to
| fill the white foreground values instead of the black background.
|
| >>> opened = im.open(kernel_size=25)
| >>> opened.plot(**kwargs)
|
| concatenate(self: 'ImageData', images: 'ImageData | Sequence[ImageData]', axis: '_AxisOptions | None' = None, *, mode: '_ConcatenateModeOptions | None' = None, dtype_policy: '_ConcatenateDTypePolicyOptions | None' = None, component_policy: '_ConcatenateComponentPolicyOptions | None' = None, background_value: 'float | VectorLike[float]' = 0.0, resample_kwargs: 'dict[str, Any] | None' = None)
| Combine multiple images into one.
|
| This filter uses :vtk:`vtkImageAppend` to combine multiple images. By default, images are
| concatenated along the specified ``axis``, and all images must have:
|
| #. identical dimensions except along the specified ``axis``,
| #. the same scalar dtype, and
| #. the same number of scalar components.
|
| Use ``mode`` for cases with mismatched dimensions, ``dtype_policy`` for cases with
| mismatched dtypes, and/or ``component_policy`` for cases with mismatched scalar components.
|
| The output has the same :attr:`~pyvista.ImageData.origin` and
| :attr:`~pyvista.ImageData.spacing` as the first input. The origin and spacing of all other
| inputs are ignored.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| images : ImageData | Sequence[ImageData]
| The input image(s) to concatenate. The default active scalars are used for all images.
|
| axis : int | str, default: 'x'
| Axis along which the images are concatenated:
|
| - ``0`` or ``'x'``: x-axis
| - ``1`` or ``'y'``: y-axis
| - ``2`` or ``'z'``: z-axis
|
| mode : str, default: 'strict'
| Concatenation mode to use. This determines how images are placed in the output. All
| modes operate along the specified ``axis`` except for ``'preserve-extents'``.
| Specify one of:
|
| - ``'strict'``: all images must have identical dimensions except along the specified
| ``axis``.
| - ``'resample-off-axis'``: :meth:`resample` off-axis dimensions of concatenated images
| to match the input. The on-axis dimension is `not` resampled.
| - ``'resample-match'``: :meth:`resample` all dimensions of concatenated images
| to match the input dimensions exactly. This is similar to ``'resample-off-axis'``,
| except the on-axis dimension is `also` resampled.
| - ``'resample-proportional'``: :meth:`resample` concatenated images proportionally to
| preserve their aspect ratio(s).
| - ``'crop-off-axis'``: :meth:`crop` off-axis dimensions of concatenated images
| to match the input. The on-axis dimension is `not` cropped.
| - ``'crop-match'``: Use :meth:`crop` to center-crop concatenated images such that
| their dimensions match the input dimensions exactly. This is similar to
| ``'crop-off-axis'``, except the on-axis dimension is `also` cropped.
| - ``'preserve-extents'``: the extents of all images are preserved and used to place the
| images in the output. The whole extent of the output is the union of the input whole
| extents. The origin and spacing is taken from the first input. ``axis`` is not used
| by this mode.
|
| .. note::
| Images may be padded with ``background_value`` in some cases when there are
| mismatched dimensions.
|
| dtype_policy : 'strict' | 'promote' | 'match', default: 'strict'
| - ``'strict'``: Do not cast any scalar array dtypes. All images being concatenated must
| have the same dtype, else a ``TypeError`` is raised.
| - ``'promote'``: Use :func:`numpy.result_type` to compute the dtype of the output
| image scalars. This option safely casts all input arrays to a common dtype before
| concatenating.
| - ``'match'``: Cast all array dtypes to match the input's dtype. This casting is
| unsafe as it may downcast values and lose precision.
|
| component_policy : 'strict' | 'promote_rgba', default: 'strict'
| - ``'strict'``: Do not modify the number of components of any scalars. All images being
| concatenated must have the same number of components, else a ``ValueError`` is
| raised.
| - ``'promote_rgba'``: Increase the number of components if necessary. Grayscale scalars
| with one component may be promoted to RGB scalars by duplicating values,
| and RGB scalars may be promoted to RGBA scalars by including an opacity component.
| For integer dtypes, the opacity is set to the max int representable by the dtype;
| for floats it is set to ``1.0``.
|
| background_value : float | VectorLike[float], default: 0
| Value or multi-component vector to use as background. The output may be padded with
| this value for some ``modes`` when there are mismatched dimensions.
|
| resample_kwargs : dict, optional
| Keyword arguments passed to :meth:`resample` when using ``'resample-off-axis'`` or
| ``'resample-proportional'`` modes. Specify ``interpolation``, ``border_mode`` or
| ``anti_aliasing`` options.
|
| Returns
| -------
| ImageData
| The concatenated image.
|
| Examples
| --------
| .. pyvista-plot::
| :force_static:
|
| Load a 2D image: :func:`~pyvista.examples.downloads.download_beach`.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beach = examples.download_beach()
|
| Use :meth:`select_values` to make a second version with white values converted to black
| to distinguish it from the original.
|
| >>> white = [255, 255, 255]
| >>> black = [0, 0, 0]
| >>> beach_black = beach.select_values(white, fill_value=black, invert=True)
|
| Concatenate them along the x-axis.
|
| >>> concatenated = beach.concatenate(beach_black, axis='x')
| >>> plot_kwargs = dict(
| ... rgb=True,
| ... lighting=False,
| ... cpos='xy',
| ... zoom='tight',
| ... show_axes=False,
| ... show_scalar_bar=False,
| ... )
| >>> concatenated.plot(**plot_kwargs)
|
| Concatenate them along the y-axis.
|
| >>> concatenated = beach.concatenate(beach_black, axis='y')
| >>> concatenated.plot(**plot_kwargs)
|
| By default, concatenation requires that all off-axis dimensions match the input. Use
| the ``mode`` keyword to enable concatenation with mismatched dimensions.
|
| Load a second 2D image with different dimensions:
| :func:`~pyvista.examples.downloads.download_bird`.
|
| >>> bird = examples.download_bird()
| >>> bird.dimensions
| (458, 342, 1)
| >>> beach.dimensions
| (100, 100, 1)
|
| Concatenate using ``'resample-proportional'`` mode to preserve the aspect ratio of the
| concatenated image. Linear interpolation with antialiasing is used to avoid sampling
| artifacts.
|
| >>> resample_kwargs = {'interpolation': 'linear', 'anti_aliasing': True}
| >>> concatenated = beach.concatenate(
| ... bird, mode='resample-proportional', resample_kwargs=resample_kwargs
| ... )
| >>> concatenated.dimensions
| (233, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'resample-proportional'`` again but concontenate along the z-axis instead. The
| ``bird``'s aspect ratio is preserved and padded with zeros so that it can be stacked
| on top of ``beach``.
|
| >>> concatenated = beach.concatenate(
| ... bird,
| ... axis='z',
| ... mode='resample-proportional',
| ... resample_kwargs=resample_kwargs,
| ... )
| >>> concatenated.dimensions
| (100, 100, 2)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'resample-off-axis'`` to only resample off-axis dimensions. This option may
| distort the image.
|
| >>> concatenated = beach.concatenate(
| ... bird, mode='resample-off-axis', resample_kwargs=resample_kwargs
| ... )
| >>> concatenated.dimensions
| (558, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'resample-match'`` to resample all dimensions to match the input exactly. This
| option may also distort the image.
|
| >>> concatenated = beach.concatenate(
| ... bird, mode='resample-match', resample_kwargs=resample_kwargs
| ... )
| >>> concatenated.dimensions
| (200, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use the ``'preserve-extents'`` mode. Using this mode naively may not produce the
| desired result, e.g. if we concatenate ``beach`` with ``bird``, the ``beach`` image is
| completely overwritten since their :attr:`~pyvista.ImageData.extent` fully overlap.
|
| >>> beach.extent
| (0, 99, 0, 99, 0, 0)
| >>> bird.extent
| (0, 457, 0, 341, 0, 0)
|
| >>> concatenated = beach.concatenate(bird, mode='preserve-extents')
| >>> concatenated.extent
| (0, 457, 0, 341, 0, 0)
| >>> concatenated.plot(**plot_kwargs)
|
| Set the ``beach`` :attr:`~pyvista.ImageData.offset` so that there is only partial
| overlap instead.
|
| >>> beach.offset = (-50, -50, 0)
| >>> beach.extent
| (-50, 49, -50, 49, 0, 0)
|
| >>> concatenated = beach.concatenate(bird, mode='preserve-extents')
| >>> concatenated.extent
| (-50, 457, -50, 341, 0, 0)
| >>> concatenated.plot(**plot_kwargs)
|
| Reverse the concatenation order, and use a green background value.
|
| >>> green = pv.Color('green').int_rgb
| >>> concatenated = bird.concatenate(
| ... beach, mode='preserve-extents', background_value=green
| ... )
| >>> concatenated.extent
| (-50, 457, -50, 341, 0, 0)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'crop-off-axis'`` to only crop off-axis dimensions.
|
| >>> concatenated = beach.concatenate(bird, mode='crop-off-axis')
| >>> concatenated.dimensions
| (558, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Reverse the concatenation order.
|
| >>> concatenated = bird.concatenate(beach, mode='crop-off-axis')
| >>> concatenated.dimensions
| (558, 342, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'crop-match'`` to center-crop the images to match the input's
| dimensions.
|
| >>> concatenated = beach.concatenate(bird, mode='crop-match')
| >>> concatenated.dimensions
| (200, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Reverse the concatenation order, and use a grey background value.
|
| >>> concatenated = bird.concatenate(
| ... beach, mode='crop-match', background_value=128
| ... )
| >>> concatenated.dimensions
| (558, 342, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Load a binary image: :func:`~pyvista.examples.downloads.download_yinyang()`.
|
| >>> yinyang = examples.download_yinyang()
|
| Use ``component_policy`` to concatenate grayscale images with RGB(A) images.
|
| >>> concatenated = yinyang.concatenate(
| ... beach, mode='resample-proportional', component_policy='promote_rgba'
| ... )
| >>> concatenated.plot(**plot_kwargs)
|
| The grayscale portion of the image is promoted to RGB in this case and the entire
| image has 3 components:
|
| >>> concatenated.active_scalars.shape
| (292068, 3)
|
| contour_labeled(self, n_labels: 'int | None' = None, smoothing: 'bool' = False, smoothing_num_iterations: 'int' = 50, smoothing_relaxation_factor: 'float' = 0.5, smoothing_constraint_distance: 'float' = 1, output_mesh_type: "Literal['quads', 'triangles']" = 'quads', output_style: "Literal['default', 'boundary']" = 'default', scalars: 'str | None' = None, progress_bar: 'bool' = False) -> 'pv.PolyData'
| Generate labeled contours from 3D label maps.
|
| SurfaceNets algorithm is used to extract contours preserving sharp
| boundaries for the selected labels from the label maps.
| Optionally, the boundaries can be smoothened to reduce the staircase
| appearance in case of low resolution input label maps.
|
| This filter requires that the :class:`ImageData` has integer point
| scalars, such as multi-label maps generated from image segmentation.
|
| .. note::
| Requires ``vtk>=9.3.0``.
|
| .. deprecated:: 0.45
| This filter produces unexpected results and is deprecated.
| Use :meth:`~pyvista.ImageDataFilters.contour_labels` instead.
| See https://github.com/pyvista/pyvista/issues/5981 for details.
|
| To replicate the default behavior from this filter, call `contour_labels`
| with the following arguments:
|
| .. code-block:: python
|
| image.contour_labels(
| boundary_style='strict_external', # old filter strictly uses external polygons
| smoothing=False, # old filter does not apply smoothing
| output_mesh_type='quads', # old filter generates quads
| pad_background=False, # old filter generates open surfaces at input edges
| orient_faces=False, # old filter does not orient faces
| simplify_output=False, # old filter returns multi-component scalars
| )
|
| Parameters
| ----------
| n_labels : int, optional
| Number of labels to be extracted (all are extracted if None is given).
|
| smoothing : bool, default: False
| Apply smoothing to the meshes.
|
| smoothing_num_iterations : int, default: 50
| Number of smoothing iterations.
|
| smoothing_relaxation_factor : float, default: 0.5
| Relaxation factor of the smoothing.
|
| smoothing_constraint_distance : float, default: 1
| Constraint distance of the smoothing.
|
| output_mesh_type : str, default: 'quads'
| Type of the output mesh. Must be either ``'quads'``, or ``'triangles'``.
|
| output_style : str, default: 'default'
| Style of the output mesh. Must be either ``'default'`` or ``'boundary'``.
| When ``'default'`` is specified, the filter produces a mesh with both
| interior and exterior polygons. When ``'boundary'`` is selected, only
| polygons on the border with the background are produced (without interior
| polygons). Note that style ``'selected'`` is currently not implemented.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| :class:`pyvista.PolyData` Labeled mesh with the segments labeled.
|
| References
| ----------
| Sarah F. Frisken, SurfaceNets for Multi-Label Segmentations with Preservation
| of Sharp Boundaries, Journal of Computer Graphics Techniques (JCGT), vol. 11,
| no. 1, 34-54, 2022. Available online http://jcgt.org/published/0011/01/03/
|
| https://www.kitware.com/really-fast-isocontouring/
|
| Examples
| --------
| See :ref:`contouring_example` for a full example using this filter.
|
| See Also
| --------
| pyvista.DataSetFilters.contour
| Generalized contouring method which uses MarchingCubes or FlyingEdges.
|
| pyvista.DataSetFilters.pack_labels
| Function used internally by SurfaceNets to generate contiguous label data.
|
| contour_labels(self: 'ImageData', boundary_style: "Literal['external', 'internal', 'all', 'strict_external']" = 'external', *, background_value: 'int' = 0, select_inputs: 'int | VectorLike[int] | None' = None, select_outputs: 'int | VectorLike[int] | None' = None, pad_background: 'bool' = True, output_mesh_type: "Literal['quads', 'triangles'] | None" = None, scalars: 'str | None' = None, orient_faces: 'bool | None' = None, simplify_output: 'bool | None' = None, smoothing: 'bool' = True, smoothing_iterations: 'int' = 16, smoothing_relaxation: 'float' = 0.5, smoothing_distance: 'float | None' = None, smoothing_scale: 'float' = 1.0, progress_bar: 'bool' = False) -> 'PolyData'
| Generate surface contours from 3D image label maps.
|
| This filter uses :vtk:`vtkSurfaceNets3D`
| to extract polygonal surface contours from non-continuous label maps, which
| corresponds to discrete regions in an input 3D image (i.e., volume). It is
| designed to generate surfaces from image point data, e.g. voxel point
| samples from 3D medical images, though images with cell data are also supported.
|
| The generated surface is smoothed using a constrained smoothing filter, which
| may be fine-tuned to control the smoothing process. Optionally, smoothing may
| be disabled to generate a staircase-like surface.
|
| The output surface includes a two-component cell data array ``'boundary_labels'``.
| The array indicates the labels/regions on either side of the polygons composing
| the output. The array's values are structured as follows:
|
| External boundary values
|
| Polygons between a foreground region and the background have the
| form ``[foreground, background]``.
|
| E.g. ``[1, 0]`` for the boundary between region ``1`` and background ``0``.
|
| Internal boundary values
|
| Polygons between two connected foreground regions are sorted in ascending order.
|
| E.g. ``[1, 2]`` for the boundary between regions ``1`` and ``2``.
|
| By default, this filter returns ``'external'`` contours only. Optionally,
| only the ``'internal'`` contours or ``'all'`` contours (i.e. internal and
| external) may be returned.
|
| .. note::
|
| This filter requires VTK version ``9.3.0`` or greater.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| boundary_style : 'external' | 'internal' | 'all' | 'strict_external', default: 'external'
| Style of boundary polygons to generate. ``'internal'`` polygons are generated
| between two connected foreground regions. ``'external'`` polygons are
| generated between foreground and background regions. ``'all'`` includes
| both internal and external boundary polygons.
|
| These styles are generated such that ``internal + external = all``.
| Internally, the filter computes all boundary polygons by default and
| then removes any undesired polygons in post-processing.
| This improves the quality of the output, but can negatively affect the
| filter's performance since all boundaries are always initially computed.
|
| The ``'strict_external'`` style can be used as a fast alternative to
| ``'external'``. This style `strictly` generates external polygons and does
| not compute or consider internal boundaries. This computation is fast, but
| also results in jagged, non-smooth boundaries between regions. The
| ``select_inputs`` and ``select_outputs`` options cannot be used with this
| style.
|
| background_value : int, default: 0
| Background value of the input image. All other values are considered
| as foreground.
|
| select_inputs : int | VectorLike[int], default: None
| Specify label ids to include as inputs to the filter. Labels that are not
| selected are removed from the input *before* generating the surface. By
| default, all label ids are used.
|
| Since the smoothing operation occurs across selected input regions, using
| this option to filter the input can result in smoother and more visually
| pleasing surfaces since non-selected inputs are not considered during
| smoothing. However, this also means that the generated surface will change
| shape depending on which inputs are selected.
|
| .. note::
|
| Selecting inputs can affect whether a boundary polygon is considered to
| be ``internal`` or ``external``. That is, an internal boundary becomes an
| external boundary when only one of the two foreground regions on the
| boundary is selected.
|
| select_outputs : int | VectorLike[int], default: None
| Specify label ids to include in the output of the filter. Labels that are
| not selected are removed from the output *after* generating the surface. By
| default, all label ids are used.
|
| Since the smoothing operation occurs across all input regions, using this
| option to filter the output means that the selected output regions will have
| the same shape (i.e. smoothed in the same manner), regardless of the outputs
| that are selected. This is useful for generating a surface for specific
| labels while also preserving sharp boundaries with non-selected outputs.
|
| .. note::
|
| Selecting outputs does not affect whether a boundary polygon is
| considered to be ``internal`` or ``external``. That is, an internal
| boundary remains internal even if only one of the two foreground regions
| on the boundary is selected.
|
| pad_background : bool, default: True
| :meth:`Pad <pyvista.ImageDataFilters.pad_image>` the image
| with ``background_value`` prior to contouring. This will
| generate polygons to "close" the surface at the boundaries of the image.
| This option is only relevant when there are foreground regions on the border
| of the image. Setting this value to ``False`` is useful if processing multiple
| volumes separately so that the generated surfaces fit together without
| creating surface overlap.
|
| output_mesh_type : str, default: None
| Type of the output mesh. Can be either ``'quads'``, or ``'triangles'``. By
| default, the output mesh has :attr:`~pyvista.CellType.TRIANGLE` cells when
| ``smoothing`` is enabled and :attr:`~pyvista.CellType.QUAD` cells (quads)
| otherwise. The mesh type can be forced to be triangles or quads; however,
| if smoothing is enabled and the type is ``'quads'``, the generated quads
| may not be planar.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars. If cell
| scalars are specified, the input image is first re-meshed with
| :meth:`~pyvista.ImageDataFilters.cells_to_points` to transform the cell
| data into point data.
|
| orient_faces : bool, optional
| .. deprecated:: 0.47
|
| This keyword should not be used and will be removed in a future version. It was
| meant to address a vtk bug where the faces generated by :vtk:`vtkSurfaceNets3D`
| have incorrect orientation. This bug is fixed in VTK 9.6, and therefore the faces
| now always have correct orientation by default.
|
| Orient the faces of the generated contours so that they have consistent
| ordering and face outward. If ``False``, the generated polygons may have
| inconsistent ordering and orientation, which can negatively impact
| downstream calculations and the shading used for rendering.
|
| .. note::
|
| Orienting the faces can be computationally expensive for large meshes.
| Consider disabling this option to improve this filter's performance.
|
| .. warning::
|
| Enabling this option is `likely` to generate surfaces with normals
| pointing outward when ``pad_background`` is ``True`` and
| ``boundary_style`` is ``'external'`` (the default). However, this is
| not guaranteed if the generated surface is not closed or if internal
| boundaries are generated. Do not assume the normals will point outward
| in all cases.
|
| simplify_output : bool, optional
| Simplify the ``'boundary_labels'`` array as a single-component 1D array.
| If ``False``, the returned ``'boundary_labels'`` array is a two-component
| 2D array. This simplification is useful when only external boundaries
| are generated and/or when visualizing internal boundaries. The
| simplification is as follows:
|
| - External boundaries are simplified by keeping the first component and
| removing the second. Since external polygons may only share a boundary
| with the background, the second component is always ``background_value``
| and therefore can be dropped without loss of information. The values
| of external boundaries always match the foreground values of the input.
|
| - Internal boundaries are simplified by assigning them unique negative
| values sequentially. E.g. the boundary label ``[1, 2]`` is replaced with
| ``-1``, ``[1, 3]`` is replaced with ``-2``, etc. The mapping to negative
| values is not fixed, and can change depending on the input.
|
| This simplification is particularly useful for unsigned integer labels
| (e.g. scalars with ``'uint8'`` dtype) since external boundaries
| will be positive and internal boundaries will be negative in this case.
|
| By default, the output is simplified when ``boundary_type`` is
| ``'external'`` or ``'strict_external'``, and is not simplified otherwise.
|
| smoothing : bool, default: True
| Smooth the generated surface using a constrained smoothing filter. Each
| point in the surface is smoothed as follows:
|
| For a point ``pi`` connected to a list of points ``pj`` via an edge, ``pi``
| is moved towards the average position of ``pj`` multiplied by the
| ``smoothing_relaxation`` factor, and limited by the ``smoothing_distance``
| constraint. This process is repeated either until convergence occurs, or
| the maximum number of ``smoothing_iterations`` is reached.
|
| smoothing_iterations : int, default: 16
| Maximum number of smoothing iterations to use.
|
| smoothing_relaxation : float, default: 0.5
| Relaxation factor used at each smoothing iteration.
|
| smoothing_distance : float, default: None
| Maximum distance each point is allowed to move (in any direction) during
| smoothing. This distance may be scaled with ``smoothing_scale``. By default,
| the distance is computed dynamically from the image spacing as:
|
| ``distance = norm(image_spacing) * smoothing_scale``.
|
| smoothing_scale : float, default: 1.0
| Relative scaling factor applied to ``smoothing_distance``. See that
| parameter for details.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of labeled regions.
|
| See Also
| --------
| :meth:`~pyvista.DataSetFilters.voxelize_binary_mask`
| Filter that generates binary labeled :class:`~pyvista.ImageData` from
| :class:`~pyvista.PolyData` surface contours. Can beloosely considered as
| an inverse of this filter.
|
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter which can used to process the multi-component
| scalars generated by this filter.
|
| :meth:`~pyvista.DataSetFilters.contour`
| Generalized contouring method which uses MarchingCubes or FlyingEdges.
|
| :meth:`~pyvista.DataSetFilters.pack_labels`
| Function used internally by SurfaceNets to generate contiguous label data.
|
| :meth:`~pyvista.DataSetFilters.color_labels`
| Color labeled data, e.g. labeled volumes or contours.
|
| :ref:`contouring_example`, :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| References
| ----------
| S. Frisken, SurfaceNets for Multi-Label Segmentations with Preservation of
| Sharp Boundaries, J. Computer Graphics Techniques, 2022. Available online:
| http://jcgt.org/published/0011/01/03/
|
| W. Schroeder, S. Tsalikis, M. Halle, S. Frisken. A High-Performance SurfaceNets
| Discrete Isocontouring Algorithm. arXiv:2401.14906. 2024. Available online:
| `http://arxiv.org/abs/2401.14906 <http://arxiv.org/abs/2401.14906>`__
|
| Examples
| --------
| Load labeled image data with a background region ``0`` and four foreground
| regions.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> label_ids = np.unique(image.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
| >>> image.dimensions
| (251, 251, 101)
|
| Crop the image to simplify the data.
|
| >>> image = image.extract_subset(voi=(75, 109, 75, 109, 85, 100))
| >>> image.dimensions
| (35, 35, 16)
|
| Plot the cropped image for context. Use :meth:`~pyvista.DataSetFilters.color_labels`
| to generate consistent coloring of the regions for all plots. Negative indexing
| is used for plotting internal boundaries.
|
| >>> def labels_plotter(mesh, zoom=None):
| ... colored_mesh = mesh.color_labels(negative_indexing=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored_mesh, show_edges=True)
| ... if zoom:
| ... pl.camera.zoom(zoom)
| ... return pl
| >>>
| >>> labels_plotter(image).show()
|
| Generate surface contours of the foreground regions and plot it. Note that
| the ``background_value`` is ``0`` by default.
|
| >>> contours = image.contour_labels()
| >>> labels_plotter(contours, zoom=1.5).show()
|
| By default, only external boundary polygons are generated and the returned
| ``'boundary_labels'`` array is a single-component array. The output values
| match the input label values.
|
| >>> contours['boundary_labels'].ndim
| 1
| >>> np.unique(contours['boundary_labels'])
| pyvista_ndarray([1, 2, 3, 4])
|
| Set ``simplify_output`` to ``False`` to generate a two-component
| array instead showing the two boundary regions associated with each polygon.
|
| >>> contours = image.contour_labels(simplify_output=False)
| >>> contours['boundary_labels'].ndim
| 2
|
| Show the unique values. Since only ``'external'`` boundaries are generated
| by default, the second component is always ``0`` (i.e. the ``background_value``).
| Note that all four foreground regions share a boundary with the background.
|
| >>> np.unique(contours['boundary_labels'], axis=0)
| array([[1, 0],
| [2, 0],
| [3, 0],
| [4, 0]])
|
| Repeat the example but this time generate internal contours only. The generated
| array is 2D by default.
|
| >>> contours = image.contour_labels('internal')
| >>> contours['boundary_labels'].ndim
| 2
|
| Show the unique two-component boundary labels again. From these values we can
| determine that all foreground regions share an internal boundary with each
| other `except` for regions ``1`` and ``3`` since the boundary value ``[1, 3]``
| is missing.
|
| >>> np.unique(contours['boundary_labels'], axis=0)
| array([[1, 2],
| [1, 4],
| [2, 3],
| [2, 4],
| [3, 4]])
|
| Simplify the output so that each internal multi-component boundary value is
| assigned a unique negative integer value instead. This makes it easier to
| visualize the result with :meth:`~pyvista.DataSetFilters.color_labels` using
| the ``negative_indexing`` option.
|
| >>> contours = image.contour_labels('internal', simplify_output=True)
| >>> contours['boundary_labels'].ndim
| 1
| >>> np.unique(contours['boundary_labels'])
| pyvista_ndarray([-5, -4, -3, -2, -1])
|
| >>> labels_plotter(contours, zoom=1.5).show()
|
| Generate contours for all boundaries, and use ``select_outputs`` to filter
| the output to only include polygons which share a boundary with region ``3``.
|
| >>> region_3 = image.contour_labels(
| ... 'all', select_outputs=3, simplify_output=True
| ... )
| >>> labels_plotter(region_3, zoom=3).show()
|
| Note how using ``select_outputs`` preserves the sharp features and boundary
| labels for non-selected regions. If desired, use ``select_inputs`` instead to
| completely "ignore" non-selected regions.
|
| >>> region_3 = image.contour_labels(select_inputs=3)
| >>> labels_plotter(region_3, zoom=3).show()
|
| The sharp features are now smoothed and the internal boundaries are now labeled
| as external boundaries. Note that using ``'all'`` here is optional since
| using ``select_inputs`` converts previously-internal boundaries into external
| ones.
|
| Do not pad the image with background values before contouring. Since the input image
| has foreground regions visible at the edges of the image (e.g. the ``+Z`` bound),
| setting ``pad_background=False`` in this example causes the top and sides of
| the mesh to be "open".
|
| >>> surf = image.contour_labels(pad_background=False)
| >>> labels_plotter(surf, zoom=1.5).show()
|
| Disable smoothing to generate staircase-like surface. Without smoothing, the
| surface has quadrilateral cells by default.
|
| >>> surf = image.contour_labels(smoothing=False)
| >>> labels_plotter(surf, zoom=1.5).show()
|
| Keep smoothing enabled but reduce the smoothing scale. A smoothing scale
| less than one may help preserve sharp features (e.g. corners).
|
| >>> surf = image.contour_labels(smoothing_scale=0.5)
| >>> labels_plotter(surf, zoom=1.5).show()
|
| Use the ``'strict_external'`` style to compute external contours quickly. Note
| that this produces jagged and non-smooth boundaries between regions, which may
| not be desirable. Also note how the top of the surface is perfectly flat compared
| to the default ``'external'`` style (see first example above) since the strict
| style ignores the smoothing effects of all internal boundaries.
|
| >>> surf = image.contour_labels('strict_external')
| >>> labels_plotter(surf, zoom=1.5).show()
|
| crop(self: 'ImageData', *, factor: 'float | VectorLike[float] | None' = None, margin: 'int | VectorLike[int] | None' = None, offset: 'VectorLike[int] | None' = None, dimensions: 'VectorLike[int] | None' = None, extent: 'VectorLike[int] | None' = None, normalized_bounds: 'VectorLike[float] | None' = None, mask: 'str | ImageData | NumpyArray[float] | Literal[True] | None' = None, padding: 'int | VectorLike[int] | None' = None, background_value: 'float | None' = None, keep_dimensions: 'bool' = False, fill_value: 'float | VectorLike[float] | None' = None, rebase_coordinates: 'bool' = False, progress_bar: 'bool' = False) -> 'ImageData'
| Crop this image to remove points at its boundaries.
|
| This filter is useful for extracting a volume or region of interest. There are several ways
| to crop:
|
| #. Use ``factor`` to crop a portion of the image symmetrically.
| #. Use ``margin`` to remove points from the image border.
| #. Use ``dimensions`` (and optionally, ``offset``) to explicitly crop to the specified
| :attr:`~pyvista.ImageData.dimensions` and :attr:`~pyvista.ImageData.offset`.
| #. Use ``extent`` to explicitly crop to a specified :attr:`~pyvista.ImageData.extent`.
| #. Use ``normalized_bounds`` to crop a bounding box relative to the input size.
| #. Use ``mask``, ``padding``, and ``background_value`` to crop to this mesh using scalar
| values to define the cropping region.
|
| These methods are all independent, e.g. it is not possible to specify both ``factor`` and
| ``margin``.
|
| By default, the cropped output's :attr:`~pyvista.ImageData.dimensions` are typically less
| than the input's dimensions. Optionally, use ``keep_dimensions`` and ``fill_value`` to
| ensure the output dimensions always match the input.
|
| .. note::
|
| All cropping is performed using the image's ijk-indices, not physical xyz-bounds.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| factor : float, optional
| Cropping factor in range ``[0.0, 1.0]`` which specifies the proportion of the image to
| keep along each axis. Use a single float for uniform cropping or a vector of three
| floats for cropping each xyz-axis independently. The crop is centered in the image.
|
| margin : int | VectorLike[int], optional
| Margin to remove from each side of each axis. Specify:
|
| - A single value to remove from all boundaries equally.
| - Two values, one for each ``(X, Y)`` axis, to remove margin from
| each axis independently.
| - Three values, one for each ``(X, Y, Z)`` axis, to remove margin from
| each axis independently.
| - Four values, one for each ``(-X, +X, -Y, +Y)`` boundary, to remove
| margin from each boundary independently.
| - Six values, one for each ``(-X, +X, -Y, +Y, -Z, +Z)`` boundary, to remove
| margin from each boundary independently.
|
| offset : VectorLike[int], optional
| Length-3 vector of integers specifying the :attr:`~pyvista.ImageData.offset` indices
| where the cropping region originates. If specified, then ``dimensions`` must also be
| provided.
|
| dimensions : VectorLike[int], optional
| Length-3 vector of integers specifying the :attr:`~pyvista.ImageData.dimensions` of
| the cropping region. ``offset`` may also be provided, but if it is not, the crop is
| centered in the image.
|
| extent : VectorLike[int], optional
| Length-6 vector of integers specifying the full :attr:`~pyvista.ImageData.extent` of
| the cropping region.
|
| normalized_bounds : VectorLike[float], optional
| Normalized bounds relative to the input. These are floats between ``0.0`` and ``1.0``
| that define a box relative to the input size. The input is cropped such that it fully
| fits within these bounds. Has the form ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| mask : str | ImageData | NumpyArray[float] | bool, optional
| Scalar values that define the cropping region. Set this option to:
|
| - a string denoting the name of scalars belonging to this mesh
| - ``True`` to use this mesh's default scalars
| - a separate image, in which case the other image's active scalars are used
| - a 1D or 2D (multi-component) array
|
| The length of the scalar array must equal the number of points.
|
| This mesh will be cropped to the bounds of the foreground values of the array, i.e.
| values that are not equal to the specified ``background_value``.
|
| padding : int | VectorLike[int], optional
| Padding to add to foreground region `before` cropping. Only valid when using a mask to
| crop the image. Specify:
|
| - A single value to pad all boundaries equally.
| - Two values, one for each ``(X, Y)`` axis, to apply symmetric padding to
| each axis independently.
| - Three values, one for each ``(X, Y, Z)`` axis, to apply symmetric padding
| to each axis independently.
| - Four values, one for each ``(-X, +X, -Y, +Y)`` boundary, to apply
| padding to each boundary independently.
| - Six values, one for each ``(-X, +X, -Y, +Y, -Z, +Z)`` boundary, to apply
| padding to each boundary independently.
|
| The specified value is the `maximum` padding that may be applied. If the padding
| extends beyond the actual extents of this mesh, it is clipped and does not extend
| outside the bounds of the image.
|
| background_value : float | VectorLike[float], optional
| Value or multi-component vector considered to be the background. Only valid when using
| a mask to crop the image.
|
| keep_dimensions : bool, default: False
| If ``True``, the cropped output is :meth:`padded <pad_image>` with ``fill_value`` to
| ensure the output dimensions match the input.
|
| fill_value : float | VectorLike[float], optional
| Value used when padding the cropped output if ``keep_dimensions`` is ``True``. May be
| a single float or a multi-component vector (e.g. RGB vector).
|
| rebase_coordinates : bool, default: False
| Rebase the coordinate reference of the cropped output:
|
| - the :attr:`~pyvista.ImageData.origin` is set to the minimum bounds of the subset
| - the :attr:`~pyvista.ImageData.offset` is reset to ``(0, 0, 0)``
|
| The rebasing effectively applies a positive translation in world (XYZ) coordinates and
| a similar (i.e. inverse) negative translation in voxel (IJK) coordinates. As a result,
| the :attr:`~pyvista.DataSet.bounds` of the output are unchanged, but the coordinate
| reference frame is modified.
|
| Set this to ``False`` to leave the origin unmodified and keep the offset used by the
| crop.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Cropped image.
|
| See Also
| --------
| pad_image
| Add points to image boundaries. This is the inverse operation of the ``margin`` crop.
|
| resample
| Modify an image's dimensions and spacing.
|
| select_values
| Threshold-like filter which may be used to generate a mask for cropping.
|
| extract_subset
| Equivalent filter to ``crop(extent=voi, rebase_coordinates=True)``.
|
| :ref:`crop_labeled_example`
| Example cropping :class:`~pyvista.ImageData` using a segmentation mask.
|
| Examples
| --------
| Load a grayscale image.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> gray_image = examples.download_yinyang()
| >>> gray_image.dimensions
| (512, 342, 1)
|
| Define a custom plotting helper to show the image as pixel cells.
|
| >>> def image_plotter(image):
| ... pixel_cells = image.points_to_cells()
| ...
| ... pl = pv.Plotter()
| ... pl.add_mesh(
| ... pixel_cells,
| ... cmap='gray',
| ... clim=[0, 255],
| ... lighting=False,
| ... show_scalar_bar=False,
| ... )
| ... pl.view_xy()
| ... pl.camera.tight()
| ... return pl
|
| Plot the image for context.
|
| >>> image_plotter(gray_image).show()
|
| Crop the white border around the image using active scalars as a mask. Here we specify a
| background value of ``255`` to correspond to white pixels. If this was an RGB image, we
| could also specify ``(255, 255, 255)`` as the background value.
|
| >>> cropped = gray_image.crop(mask=True, background_value=255)
| >>> cropped.dimensions
| (237, 238, 1)
| >>> image_plotter(cropped).show()
|
| Use ``margin`` instead to remove 100 and 20 pixels from each side of the x- and y-axis,
| respectively.
|
| >>> cropped = gray_image.crop(margin=(100, 20))
| >>> cropped.dimensions
| (312, 302, 1)
| >>> image_plotter(cropped).show()
|
| Use ``offset`` to select a starting location for the crop (from the origin at the
| bottom-left corner) along with ``dimensions`` to define the crop size.
|
| >>> cropped = gray_image.crop(offset=(50, 20, 0), dimensions=(300, 200, 1))
| >>> cropped.dimensions
| (300, 200, 1)
| >>> image_plotter(cropped).show()
|
| Use ``extent`` directly instead of using ``dimensions`` and ``offset`` to yield the same
| result as above.
|
| >>> cropped = gray_image.crop(extent=(50, 349, 20, 219, 0, 0))
| >>> cropped.extent
| (50, 349, 20, 219, 0, 0)
| >>> image_plotter(cropped).show()
|
| Use ``factor`` to crop 40% of the image. This `keeps` 40% of the pixels along each axis,
| and `removes` 60% (i.e. 30% from each side).
|
| >>> cropped = gray_image.crop(factor=0.4)
| >>> cropped.dimensions
| (204, 136, 1)
| >>> image_plotter(cropped).show()
|
| Use ``normalized_bounds`` to crop from 40% to 80% of the image along the x-axis, and
| from 30% to 90% of the image along the y-axis.
|
| >>> cropped = gray_image.crop(normalized_bounds=[0.4, 0.8, 0.3, 0.9, 0.0, 1.0])
| >>> cropped.extent
| (205, 408, 103, 306, 0, 0)
| >>> image_plotter(cropped).show()
|
| dilate(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Morphologically dilate grayscale or binary data.
|
| This filter may be used to dilate grayscale images with continuous data, binary images
| with a single background and foreground value, or multi-label images.
|
| For binary inputs with two unique values, this filter uses :vtk:`vtkImageDilateErode3D`
| by default to perform fast binary dilation over an ellipsoidal neighborhood. Otherwise,
| the slower class :vtk:`vtkImageContinuousDilate3D` is used to perform generalized grayscale
| dilation by replacing each pixel with the maximum over an ellipsoidal neighborhood.
|
| Optionally, the ``binary`` keyword may be used to explicitly control the behavior of the
| filter.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are dilated, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary dilation or continuous dilation is used.
|
| If set, :vtk:`vtkImageDilateErode3D` is used to strictly dilate with two values.
| Set this to ``True`` to dilate the maximum value in ``scalars`` with its minimum value,
| or set it to two values ``[background_value, foreground_value]`` to dilate
| ``foreground_value`` with ``background_value`` explicitly.
|
| Set this to ``False`` to use :vtk:`vtkImageContinuousDilate3D` to perform continuous
| dilation.
|
| By default, ``binary`` is ``True`` if the input has two unique values, and ``False``
| otherwise.
|
| .. note::
| - If the input is a binary mask, setting ``binary=True`` produces the same output
| as ``binary=False``, but the filter is much more performant.
| - Setting ``binary=[background_value, foreground_value]`` is useful to `isolate`
| the dilation to two values, e.g. for multi-label segmentation masks.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been dilated.
|
| See Also
| --------
| erode, open, close
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| .. pyvista-plot::
| :force_static:
|
| Create a toy example with two non-zero grayscale foreground values
| :meth:`padded <pad_image>` with a background of zeros.
|
| >>> import pyvista as pv
| >>> im = pv.ImageData(dimensions=(2, 1, 1))
| >>> im['data'] = [128, 255]
| >>> im = im.pad_image(pad_value=0, pad_size=2, dimensionality=2)
|
| Define a custom plotter to plot pixels as cells.
|
| >>> def image_plotter(image):
| ... pl = pv.Plotter()
| ... pl.add_mesh(
| ... image.points_to_cells(),
| ... cmap='grey',
| ... clim=[0, 255],
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... lighting=False,
| ... line_width=3,
| ... )
| ... pl.camera_position = 'xy'
| ... pl.camera.tight()
| ... pl.enable_anti_aliasing()
| ... return pl
|
| Show the image.
|
| >>> image_plotter(im).show()
|
| Dilate it with default settings. Observe that `both` foreground values are dilated.
|
| >>> dilated = im.dilate()
| >>> image_plotter(dilated).show()
|
| Use a larger kernel size.
|
| >>> dilated = im.dilate(kernel_size=5)
| >>> image_plotter(dilated).show()
|
| Use an asymmetric kernel.
|
| >>> dilated = im.dilate(kernel_size=(2, 4, 1))
| >>> image_plotter(dilated).show()
|
| Use binary dilation. By default, the max value (``255`` in this example) is dilated
| with the min value (``0`` in this example). All other values are unaffected.
|
| >>> dilated = im.dilate(binary=True)
| >>> image_plotter(dilated).show()
|
| Equivalently, set the binary values for the dilation explicitly.
|
| >>> dilated = im.dilate(binary=[0, 255])
| >>> image_plotter(dilated).show()
|
| Use binary dilation with the other foreground value instead.
|
| >>> dilated = im.dilate(binary=[0, 128])
| >>> image_plotter(dilated).show()
|
| erode(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Morphologically erode grayscale or binary data.
|
| This filter may be used to erode grayscale images with continuous data, binary images
| with a single background and foreground value, or multi-label images.
|
| For binary inputs with two unique values, this filter uses :vtk:`vtkImageDilateErode3D`
| by default to perform fast binary erosion over an ellipsoidal neighborhood. Otherwise,
| the slower class :vtk:`vtkImageContinuousErode3D` is used to perform generalized grayscale
| erosion by replacing each pixel with the minimum over an ellipsoidal neighborhood.
|
| Optionally, the ``binary`` keyword may be used to explicitly control the behavior of the
| filter.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are eroded, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary erosion or continuous erosion is used.
|
| If set, :vtk:`vtkImageDilateErode3D` is used to strictly erode with two values.
| Set this to ``True`` to erode the maximum value in ``scalars`` with its minimum value,
| or set it to two values ``[background_value, foreground_value]`` to erode
| ``foreground_value`` with ``background_value`` explicitly.
|
| Set this to ``False`` to use :vtk:`vtkImageContinuousErode3D` to perform continuous
| erosion.
|
| By default, ``binary`` is ``True`` if the input has two unique values, and ``False``
| otherwise.
|
| .. note::
| - If the input is a binary mask, setting ``binary=True`` produces the same output
| as ``binary=False``, but the filter is much more performant.
| - Setting ``binary=[background_value, foreground_value]`` is useful to `isolate`
| the erosion to two values, e.g. for multi-label segmentation masks.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been eroded.
|
| See Also
| --------
| dilate, open, close
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| .. pyvista-plot::
| :force_static:
|
| Create a toy example with two non-zero grayscale foreground regions
| using :meth:`pad_image`.
|
| >>> import pyvista as pv
| >>> # Create an initial background point
| >>> im = pv.ImageData(dimensions=(1, 1, 1))
| >>> im['data'] = [0]
| >>> # Add a foreground region
| >>> im = im.pad_image(pad_value=255, pad_size=(4, 3), dimensionality=2)
| >>> # Add a second foreground region
| >>> im = im.pad_image(pad_value=128, pad_size=(2, 0, 1, 0))
| >>> # Add background values to two sides
| >>> im = im.pad_image(pad_value=0, pad_size=(1, 0))
|
| Define a custom plotter to plot pixels as cells.
|
| >>> def image_plotter(image):
| ... pl = pv.Plotter()
| ... pl.add_mesh(
| ... image.points_to_cells(),
| ... cmap='grey',
| ... clim=[0, 255],
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... lighting=False,
| ... line_width=3,
| ... )
| ... pl.camera_position = 'xy'
| ... pl.camera.tight()
| ... pl.enable_anti_aliasing()
| ... return pl
|
| Show the image.
|
| >>> image_plotter(im).show()
|
| Erode it with default settings. Observe that `both` foreground values are eroded.
|
| >>> eroded = im.erode()
| >>> image_plotter(eroded).show()
|
| Use a larger kernel size.
|
| >>> eroded = im.erode(kernel_size=5)
| >>> image_plotter(eroded).show()
|
| Use an asymmetric kernel.
|
| >>> eroded = im.erode(kernel_size=(2, 4, 1))
| >>> image_plotter(eroded).show()
|
| Use binary erosion. By default, the max value (``255`` in this example) is eroded
| with the min value (``0`` in this example). All other values are unaffected.
|
| >>> eroded = im.erode(binary=True)
| >>> image_plotter(eroded).show()
|
| Equivalently, set the binary values for the erosion explicitly.
|
| >>> eroded = im.erode(binary=[0, 255])
| >>> image_plotter(eroded).show()
|
| Use binary erosion with the other foreground value instead.
|
| >>> eroded = im.erode(binary=[0, 128])
| >>> image_plotter(eroded).show()
|
| extract_subset(self, voi, rate=(1, 1, 1), boundary: 'bool' = False, rebase_coordinates: 'bool' = True, progress_bar: 'bool' = False)
| Select piece (e.g., volume of interest).
|
| To use this filter set the VOI ivar which are i-j-k min/max indices
| that specify a rectangular region in the data. (Note that these are
| 0-offset.) You can also specify a sampling rate to subsample the
| data.
|
| Typical applications of this filter are to extract a slice from a
| volume for image processing, subsampling large volumes to reduce data
| size, or extracting regions of a volume with interesting data.
|
| Parameters
| ----------
| voi : sequence[int]
| Length 6 iterable of ints: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| These bounds specify the volume of interest in i-j-k min/max
| indices.
|
| rate : sequence[int], default: (1, 1, 1)
| Length 3 iterable of ints: ``(xrate, yrate, zrate)``.
|
| boundary : bool, default: False
| Control whether to enforce that the "boundary" of the grid
| is output in the subsampling process. This only has effect
| when the rate in any direction is not equal to 1. When
| this is enabled, the subsampling will always include the
| boundary of the grid even though the sample rate is not an
| even multiple of the grid dimensions. By default this is
| disabled.
|
| rebase_coordinates : bool, default: True
| If ``True`` (default), reset the coordinate reference of the extracted subset:
|
| - the :attr:`~pyvista.ImageData.origin` is set to the minimum bounds of the subset
| - the :attr:`~pyvista.ImageData.offset` is reset to ``(0, 0, 0)``
|
| The rebasing effectively applies a positive translation in world (XYZ) coordinates and
| a similar (i.e. inverse) negative translation in voxel (IJK) coordinates. As a result,
| the :attr:`~pyvista.DataSet.bounds` of the output are unchanged, but the coordinate
| reference frame is modified.
|
| Set this to ``False`` to leave the origin unmodified and keep the offset specified by
| the ``voi`` parameter.
|
| .. versionadded:: 0.46
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| ImageData subset.
|
| See Also
| --------
| slice_index
| crop
|
| fft(self, output_scalars_name=None, progress_bar: 'bool' = False)
| Apply a fast Fourier transform (FFT) to the active scalars.
|
| The input can be real or complex data, but the output is always
| :attr:`numpy.complex128`. The filter is fastest for images that have
| power of two sizes.
|
| The filter uses a butterfly diagram for each prime factor of the
| dimension. This makes images with prime number dimensions (i.e. 17x17)
| much slower to compute. FFTs of multidimensional meshes (i.e volumes)
| are decomposed so that each axis executes serially.
|
| The frequencies of the output assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with applied FFT.
|
| See Also
| --------
| rfft : The reverse transform.
| low_pass : Low-pass filtering of FFT output.
| high_pass : High-pass filtering of FFT output.
|
| Examples
| --------
| Apply FFT to an example image.
|
| >>> from pyvista import examples
| >>> image = examples.download_moonlanding_image()
| >>> fft_image = image.fft()
| >>> fft_image.point_data # doctest:+SKIP
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : PNGImage
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| PNGImage complex128 (298620,) SCALARS
|
| See :ref:`image_fft_example` for a full example using this filter.
|
| gaussian_smooth(self, radius_factor=1.5, std_dev=2.0, scalars=None, progress_bar: 'bool' = False)
| Smooth the data with a Gaussian kernel.
|
| Parameters
| ----------
| radius_factor : float | sequence[float], default: 1.5
| Unitless factor to limit the extent of the kernel.
|
| std_dev : float | sequence[float], default: 2.0
| Standard deviation of the kernel in pixel units.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Uniform grid with smoothed scalars.
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| First, create sample data to smooth. Here, we use
| :func:`pyvista.perlin_noise() <pyvista.core.utilities.features.perlin_noise>`
| to create meaningful data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 5, 8), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1, 0, 1, 0, 1], dim=(20, 20, 20)
| ... )
| >>> grid.plot(show_scalar_bar=False)
|
| Next, smooth the sample data.
|
| >>> smoothed = grid.gaussian_smooth()
| >>> smoothed.plot(show_scalar_bar=False)
|
| See :ref:`gaussian_smoothing_example` for a full example using this filter.
|
| high_pass(self, x_cutoff, y_cutoff, z_cutoff, order=1, output_scalars_name=None, progress_bar: 'bool' = False)
| Perform a Butterworth high pass filter in the frequency domain.
|
| This filter requires that the :class:`ImageData` have a complex point
| scalars, usually generated after the :class:`ImageData` has been
| converted to the frequency domain by a :func:`ImageDataFilters.fft`
| filter.
|
| A :func:`ImageDataFilters.rfft` filter can be used to convert the
| output back into the spatial domain. This filter attenuates low
| frequency components. Input and output are complex arrays with
| datatype :attr:`numpy.complex128`.
|
| The frequencies of the input assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| x_cutoff : float
| The cutoff frequency for the x-axis.
|
| y_cutoff : float
| The cutoff frequency for the y-axis.
|
| z_cutoff : float
| The cutoff frequency for the z-axis.
|
| order : int, default: 1
| The order of the cutoff curve. Given from the equation
| ``1/(1 + (cutoff/freq(i, j))**(2*order))``.
|
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with the applied high pass filter.
|
| See Also
| --------
| fft : Direct fast Fourier transform.
| rfft : Reverse fast Fourier transform.
| low_pass : Low-pass filtering of FFT output.
|
| Examples
| --------
| See :ref:`image_fft_perlin_noise_example` for a full example using this filter.
|
| image_dilate_erode(self, dilate_value=1.0, erode_value=0.0, kernel_size=(3, 3, 3), scalars=None, progress_bar: 'bool' = False)
| Dilates one value and erodes another.
|
| .. deprecated:: 0.47.0
| :meth:`image_dilate_erode` is deprecated. Use :meth:`dilate`, :meth:`erode`,
| :meth:`open`, or :meth:`close` instead.
|
| ``image_dilate_erode`` will dilate one value and erode another. It uses
| an elliptical footprint, and only erodes/dilates on the boundary of the
| two values. The filter is restricted to the X, Y, and Z axes for now.
| It can degenerate to a 2 or 1-dimensional filter by setting the kernel
| size to 1 for a specific axis.
|
| Parameters
| ----------
| dilate_value : float, default: 1.0
| Dilate value in the dataset.
|
| erode_value : float, default: 0.0
| Erode value in the dataset.
|
| kernel_size : sequence[int], default: (3, 3, 3)
| Determines the size of the kernel along the three axes.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been dilated/eroded on the boundary of the specified scalars.
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| Demonstrate image dilate/erode on an example dataset. First, plot
| the example dataset with the active scalars.
|
| >>> from pyvista import examples
| >>> uni = examples.load_uniform()
| >>> uni.plot()
|
| Now, plot the image threshold with ``threshold=[400, 600]``. Note how
| values within the threshold are 1 and outside are 0.
|
| >>> ithresh = uni.image_threshold([400, 600])
| >>> ithresh.plot()
|
| Note how there is a hole in the thresholded image. Apply a closing
| filter with a large kernel to fill that hole in.
|
| >>> iclosed = ithresh.close(kernel_size=[5, 5, 5])
| >>> iclosed.plot()
|
| image_threshold(self: 'ImageData', threshold, in_value=1.0, out_value=0.0, scalars=None, preference='point', progress_bar: 'bool' = False)
| Apply a threshold to scalar values in a uniform grid.
|
| If a single value is given for threshold, scalar values above or equal
| to the threshold are ``'in'`` and scalar values below the threshold are ``'out'``.
| If two values are given for threshold (sequence) then values equal to
| or between the two values are ``'in'`` and values outside the range are ``'out'``.
|
| If ``None`` is given for ``in_value``, scalars that are ``'in'`` will not be replaced.
| If ``None`` is given for ``out_value``, scalars that are ``'out'`` will not be replaced.
|
| Warning: applying this filter to cell data will send the output to a
| new point array with the same name, overwriting any existing point data
| array with the same name.
|
| Parameters
| ----------
| threshold : float or sequence[float]
| Single value or (min, max) to be used for the data threshold. If
| a sequence, then length must be 2. Threshold(s) for deciding which
| cells/points are ``'in'`` or ``'out'`` based on scalar data.
|
| in_value : float, default: 1.0
| Scalars that match the threshold criteria for ``'in'`` will be replaced with this.
|
| out_value : float, default: 0.0
| Scalars that match the threshold criteria for ``'out'`` will be replaced with this.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset with the specified scalars thresholded.
|
| See Also
| --------
| select_values
| Threshold-like method for keeping some values and replacing others.
| :meth:`~pyvista.DataSetFilters.threshold`
| General threshold method that returns a :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Demonstrate image threshold on an example dataset. First, plot
| the example dataset with the active scalars.
|
| >>> from pyvista import examples
| >>> uni = examples.load_uniform()
| >>> uni.plot()
|
| Now, plot the image threshold with ``threshold=100``. Note how
| values above the threshold are 1 and below are 0.
|
| >>> ithresh = uni.image_threshold(100)
| >>> ithresh.plot()
|
| See :ref:`image_representations_example` for more examples using this filter.
|
| label_connectivity(self, *, scalars: 'str | None' = None, scalar_range: "Literal['auto', 'foreground', 'vtk_default'] | VectorLike[float]" = 'auto', extraction_mode: "Literal['all', 'largest', 'seeded']" = 'all', point_seeds: 'MatrixLike[float] | VectorLike[float] | _vtk.vtkDataSet | None' = None, label_mode: "Literal['size', 'constant', 'seeds']" = 'size', constant_value: 'int | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False) -> 'tuple[ImageData, NDArray[int], NDArray[int]]'
| Find and label connected regions in a :class:`~pyvista.ImageData`.
|
| Only points whose `scalar` value is within the `scalar_range` are considered for
| connectivity. A 4-connectivity is used for 2D images or a 6-connectivity for 3D
| images. This filter operates on point-based data. If cell-based data are provided,
| they are re-meshed to a point-based representation using
| :func:`~pyvista.ImageDataFilters.cells_to_points` and the output is meshed back
| to a cell-based representation with :func:`~pyvista.ImageDataFilters.points_to_cells`,
| effectively filtering based on face connectivity. The connected regions are
| extracted and labelled according to the strategy defined by ``extraction_mode``
| and ``label_mode``, respectively. Unconnected regions are labelled with ``0`` value.
|
| .. versionadded:: 0.45.0
|
| Notes
| -----
| This filter implements :vtk:`vtkImageConnectivityFilter`.
|
| Parameters
| ----------
| scalars : str, optional
| Scalars to use to filter points. If ``None`` is provided, the scalars is
| automatically set, if possible.
|
| scalar_range : str, Literal['auto', 'foreground', 'vtk_default'], VectorLike[float]
| Points whose scalars value is within ``'scalar_range'`` are considered for
| connectivity. The bounds are inclusive.
|
| - ``'auto'``: (default) includes the full data range, similarly to
| :meth:`~pyvista.DataSetFilters.connectivity`.
| - ``'foreground'``: includes the full data range except the smallest value.
| - ``'vtk_default'``: default to [``0.5``, :const:`~vtk.VTK_DOUBLE_MAX`].
| - ``VectorLike[float]``: explicitly set the range.
|
| The bounds are always cast to floats since vtk expects doubles. The scalars
| data are also cast to floats to avoid unexpected behavior arising from implicit
| type conversion. The only exceptions is if both bounds are whole numbers, in
| which case the implicit conversion is safe. It will optimize resources consumption
| if the data are integers.
|
| extraction_mode : Literal['all', 'largest', 'seeded'], default: 'all'
| Determine how the connected regions are extracted. If ``'all'``, all connected
| regions are extracted. If ``'largest'``, only the largest region is extracted.
| If ``'seeded'``, only the regions that include the points defined with
| ``point_seeds`` are extracted.
|
| point_seeds : MatrixLike[float], VectorLike[float], :vtk:`vtkDataSet`, optional
| The point coordinates to use as seeds, specified as a (N, 3) array like or
| as a :vtk:`vtkDataSet`. Has no effect if ``extraction_mode`` is not
| ``'seeded'``.
|
| label_mode : Literal['size', 'constant', 'seeds'], default: 'size'
| Determine how the extracted regions are labelled. If ``'size'``, label regions
| by decreasing size (i.e., count of cells), starting at ``1``. If ``'constant'``,
| label with the provided ``constant_value``. If ``'seeds'``, label according to
| the seed order, starting at ``1``.
|
| constant_value : int, optional
| The constant label value to use. Has no effect if ``label_mode`` is not ``'seeds'``.
|
| inplace : bool, default: False
| If ``True``, perform an inplace labelling of the ImageData. Else, returns a
| new ImageData.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Either the input ImageData or a generated one where connected regions are
| labelled with a ``'RegionId'`` point-based or cell-based data.
|
| NDArray[int]
| The labels of each extracted regions.
|
| NDArray[int]
| The size (i.e., number of cells) of each extracted regions.
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Similar general-purpose filter that performs 1-connectivity.
|
| Examples
| --------
| Prepare a segmented grid.
|
| >>> import pyvista as pv
| >>> segmented_grid = pv.ImageData(dimensions=(4, 3, 3))
| >>> segmented_grid.cell_data['Data'] = [
| ... 0,
| ... 0,
| ... 0,
| ... 1,
| ... 0,
| ... 1,
| ... 1,
| ... 2,
| ... 0,
| ... 0,
| ... 0,
| ... 0,
| ... ]
| >>> segmented_grid.plot(show_edges=True)
|
| Label the connected regions. The cells with a ``0`` value are excluded from the
| connected regions and labelled with ``0``. The remaining cells define 3 different
| regions that are labelled by decreasing size.
|
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range='foreground'
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| Exclude the cell with a ``2`` value.
|
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range=[1, 1]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| Label all connected regions with a constant value.
|
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range='foreground',
| ... label_mode='constant',
| ... constant_value=10,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| Label only the regions that include seed points, by seed order.
|
| >>> points = [(2.0, 1.0, 0.0), (0.0, 0.0, 1.0)]
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range='foreground',
| ... extraction_mode='seeded',
| ... point_seeds=points,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| low_pass(self, x_cutoff, y_cutoff, z_cutoff, order=1, output_scalars_name=None, progress_bar: 'bool' = False)
| Perform a Butterworth low pass filter in the frequency domain.
|
| This filter requires that the :class:`ImageData` have a complex point
| scalars, usually generated after the :class:`ImageData` has been
| converted to the frequency domain by a :func:`ImageDataFilters.fft`
| filter.
|
| A :func:`ImageDataFilters.rfft` filter can be used to convert the
| output back into the spatial domain. This filter attenuates high
| frequency components. Input and output are complex arrays with
| datatype :attr:`numpy.complex128`.
|
| The frequencies of the input assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| x_cutoff : float
| The cutoff frequency for the x-axis.
|
| y_cutoff : float
| The cutoff frequency for the y-axis.
|
| z_cutoff : float
| The cutoff frequency for the z-axis.
|
| order : int, default: 1
| The order of the cutoff curve. Given from the equation
| ``1 + (cutoff/freq(i, j))**(2*order)``.
|
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with the applied low pass filter.
|
| See Also
| --------
| fft : Direct fast Fourier transform.
| rfft : Reverse fast Fourier transform.
| high_pass : High-pass filtering of FFT output.
|
| Examples
| --------
| See :ref:`image_fft_perlin_noise_example` for a full example using this filter.
|
| median_smooth(self, kernel_size=(3, 3, 3), scalars=None, preference='point', progress_bar: 'bool' = False)
| Smooth data using a median filter.
|
| The Median filter that replaces each pixel with the median value from a
| rectangular neighborhood around that pixel. Neighborhoods can be no
| more than 3 dimensional. Setting one axis of the neighborhood
| kernelSize to 1 changes the filter into a 2D median.
|
| See :vtk:`vtkImageMedian3D` for more details.
|
| Parameters
| ----------
| kernel_size : sequence[int], default: (3, 3, 3)
| Size of the kernel in each dimension (units of voxels), for example
| ``(x_size, y_size, z_size)``. Default is a 3D median filter. If you
| want to do a 2D median filter, set the size to 1 in the dimension
| you don't want to filter over.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Uniform grid with smoothed scalars.
|
| Warnings
| --------
| Applying this filter to cell data will send the output to a new point
| array with the same name, overwriting any existing point data array
| with the same name.
|
| Examples
| --------
| First, create sample data to smooth. Here, we use
| :func:`pyvista.perlin_noise() <pyvista.core.utilities.features.perlin_noise>`
| to create meaningful data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 5, 8), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1, 0, 1, 0, 1], dim=(20, 20, 20)
| ... )
| >>> grid.plot(show_scalar_bar=False)
|
| Next, smooth the sample data.
|
| >>> smoothed = grid.median_smooth(kernel_size=(10, 10, 10))
| >>> smoothed.plot(show_scalar_bar=False)
|
| open(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Perform morphological opening on continuous or binary data.
|
| Opening is an :meth:`erosion <erode>` followed by a :meth:`dilation <dilate>`.
| It is used to remove small objects/noise while preserving the shape and size of larger
| objects.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are opened, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary opening or continuous opening is used. Refer to
| :meth:`erode` and/or :meth:`dilate` for details about using this keyword.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been opened.
|
| See Also
| --------
| close, erode, dilate
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| Load a grayscale image :func:`~pyvista.examples.downloads.download_chest()` and show it
| for context.
|
| >>> from pyvista import examples
| >>> im = examples.download_chest()
| >>> clim = im.get_data_range()
| >>> kwargs = dict(
| ... cmap='grey',
| ... clim=clim,
| ... lighting=False,
| ... cpos='xy',
| ... zoom='tight',
| ... show_axes=False,
| ... show_scalar_bar=False,
| ... )
| >>> im.plot(**kwargs)
|
| Use ``open`` to remove small objects in the lungs.
|
| >>> opened = im.open(kernel_size=15)
| >>> opened.plot(**kwargs)
|
| pad_image(self, pad_value: "float | VectorLike[float] | Literal['wrap', 'mirror']" = 0.0, *, pad_size: 'int | VectorLike[int]' = 1, dimensionality: "VectorLike[bool] | Literal[0, 1, 2, 3, '0D', '1D', '2D', '3D', 'preserve']" = 'preserve', scalars: 'str | None' = None, pad_all_scalars: 'bool' = False, progress_bar: 'bool' = False) -> 'ImageData'
| Enlarge an image by padding its boundaries with new points.
|
| .. versionadded:: 0.44.0
|
| Padded points may be mirrored, wrapped, or filled with a constant value. By
| default, all boundaries of the image are padded with a single constant value.
|
| This filter is designed to work with 1D, 2D, or 3D image data and will only pad
| non-singleton dimensions unless otherwise specified.
|
| Parameters
| ----------
| pad_value : float | sequence[float] | 'mirror' | 'wrap', default: 0.0
| Padding value(s) given to new points outside the original image extent.
| Specify:
|
| - a number: New points are filled with the specified constant value.
| - a vector: New points are filled with the specified multi-component vector.
| - ``'wrap'``: New points are filled by wrapping around the padding axis.
| - ``'mirror'``: New points are filled by mirroring the padding axis.
|
| pad_size : int | sequence[int], default: 1
| Number of points to add to the image boundaries. Specify:
|
| - A single value to pad all boundaries equally.
| - Two values, one for each ``(X, Y)`` axis, to apply symmetric padding to
| each axis independently.
| - Three values, one for each ``(X, Y, Z)`` axis, to apply symmetric padding
| to each axis independently.
| - Four values, one for each ``(-X, +X, -Y, +Y)`` boundary, to apply
| padding to each boundary independently.
| - Six values, one for each ``(-X, +X, -Y, +Y, -Z, +Z)`` boundary, to apply
| padding to each boundary independently.
|
| dimensionality : VectorLike[bool], Literal[1, 2, 3, "1D", "2D", "3D", "preserve"]
| Control which dimensions will be padded by the filter.
| ``'preserve'`` is used by default.
|
| - Can be specified as a sequence of 3 boolean to apply padding on a per
| dimension basis.
| - ``1`` or ``'1D'``: apply padding such that the output is a 1D ImageData
| where exactly one dimension is greater than one, e.g. ``(>1, 1, 1)``.
| Only valid for 0D or 1D inputs.
| - ``2`` or ``'2D'``: apply padding such that the output is a 2D ImageData
| where exactly two dimensions are greater than one, e.g. ``(>1, >1, 1)``.
| Only valid for 0D, 1D, or 2D inputs.
| - ``3`` or ``'3D'``: apply padding such that the output is a 3D ImageData,
| where all three dimensions are greater than one, e.g. ``(>1, >1, >1)``.
| Valid for any 0D, 1D, 2D, or 3D inputs.
|
| .. note::
| The ``pad_size`` for singleton dimensions is set to ``0`` by default, even
| if non-zero pad sizes are specified for these axes with this parameter.
| Set ``dimensionality`` to a value different than ``'preserve'`` to
| override this behavior and enable padding any or all dimensions.
|
| .. versionadded:: 0.45.0
|
| scalars : str, optional
| Name of scalars to pad. Defaults to currently active scalars. Unless
| ``pad_all_scalars`` is ``True``, only the specified ``scalars`` are included
| in the output.
|
| pad_all_scalars : bool, default: False
| Pad all point data scalars and include them in the output. This is useful
| for padding images with multiple scalars. If ``False``, only the specified
| ``scalars`` are padded.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Padded image.
|
| See Also
| --------
| crop, resample, contour_labels
|
| Examples
| --------
| Pad a grayscale image with a 100-pixel wide border. The padding is black
| (i.e. has a value of ``0``) by default.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>>
| >>> gray_image = examples.download_moonlanding_image()
| >>> gray_image.dimensions
| (630, 474, 1)
| >>> padded = gray_image.pad_image(pad_size=100)
| >>> padded.dimensions
| (830, 674, 1)
|
| Plot the image. To show grayscale images correctly, we define a custom plotting
| method.
|
| >>> def grayscale_image_plotter(image):
| ... import vtk
| ...
| ... actor = vtk.vtkImageActor()
| ... actor.GetMapper().SetInputData(image)
| ... actor.GetProperty().SetInterpolationTypeToNearest()
| ... pl = pv.Plotter()
| ... pl.add_actor(actor)
| ... pl.view_xy()
| ... pl.camera.tight()
| ... return pl
| >>>
| >>> pl = grayscale_image_plotter(padded)
| >>> pl.show()
|
| Pad only the x-axis with a white border.
|
| >>> padded = gray_image.pad_image(pad_value=255, pad_size=(200, 0))
| >>> pl = grayscale_image_plotter(padded)
| >>> pl.show()
|
| Pad with wrapping.
|
| >>> padded = gray_image.pad_image('wrap', pad_size=100)
| >>> plot = grayscale_image_plotter(padded)
| >>> plot.show()
|
| Pad with mirroring.
|
| >>> padded = gray_image.pad_image('mirror', pad_size=100)
| >>> plot = grayscale_image_plotter(padded)
| >>> plot.show()
|
| Pad a color image using multi-component color vectors. Here, RGBA values are
| used.
|
| >>> color_image = examples.download_beach()
| >>> red = (255, 0, 0) # RGB
| >>> padded = color_image.pad_image(pad_value=red, pad_size=50)
| >>>
| >>> plot_kwargs = dict(cpos='xy', zoom='tight', rgb=True, show_axes=False)
| >>> padded.plot(**plot_kwargs)
|
| Pad each edge of the image separately with a different color.
|
| >>> orange = pv.Color('orange').int_rgb
| >>> purple = pv.Color('purple').int_rgb
| >>> blue = pv.Color('blue').int_rgb
| >>> green = pv.Color('green').int_rgb
| >>>
| >>> padded = color_image.pad_image(orange, pad_size=(25, 0, 0, 0))
| >>> padded = padded.pad_image(purple, pad_size=(0, 25, 0, 0))
| >>> padded = padded.pad_image(blue, pad_size=(0, 0, 25, 0))
| >>> padded = padded.pad_image(green, pad_size=(0, 0, 0, 25))
| >>>
| >>> padded.plot(**plot_kwargs)
|
| points_to_cells(self: 'ImageData', scalars: 'str | None' = None, *, dimensionality: "VectorLike[bool] | Literal[0, 1, 2, 3, '0D', '1D', '2D', '3D', 'preserve']" = 'preserve', copy: 'bool' = True)
| Re-mesh image data from a point-based to a cell-based representation.
|
| This filter changes how image data is represented. Data represented as points
| at the input is re-meshed into an alternative representation as cells at the
| output. Only the :class:`~pyvista.ImageData` container is modified so that
| the number of input points equals the number of output cells. The re-meshing is
| otherwise lossless in the sense that point data at the input is passed through
| unmodified and stored as cell data at the output. Any cell data at the input is
| ignored and is not used by this filter.
|
| To change the image data's representation, the input points are used to
| represent the centers of the output cells. This has the effect of "growing" the
| input image dimensions by one along each axis (i.e. half the cell width on each
| side). For example, an image with 100 points and 99 cells along an axis at the
| input will have 101 points and 100 cells at the output. If the input has 1mm
| spacing, the axis size will also increase from 99mm to 100mm. By default,
| only non-singleton dimensions are increased such that 1D or 2D inputs remain
| 1D or 2D at the output.
|
| Since filters may be inherently cell-based (e.g. some :class:`~pyvista.DataSetFilters`)
| or may operate on point data exclusively (e.g. most :class:`~pyvista.ImageDataFilters`),
| re-meshing enables the same data to be used with either kind of filter while
| ensuring the input data to those filters has the appropriate representation.
| This filter is also useful when plotting image data to achieve a desired visual
| effect, such as plotting images as voxel cells instead of as points.
|
| .. note::
| Only the input's :attr:`~pyvista.ImageData.dimensions`, and
| :attr:`~pyvista.ImageData.origin` are modified by this filter. Other spatial
| properties such as :attr:`~pyvista.ImageData.spacing` and
| :attr:`~pyvista.ImageData.direction_matrix` are not affected.
|
| .. versionadded:: 0.44.0
|
| See Also
| --------
| cells_to_points
| Inverse of this filter to represent cells as points.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample point data as cell data without modifying the container.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample cell data as point data without modifying the container.
|
| Parameters
| ----------
| scalars : str, optional
| Name of point data scalars to pass through to the output as cell data. Use
| this parameter to restrict the output to only include the specified array.
| By default, all point data arrays at the input are passed through as cell
| data at the output.
|
| dimensionality : VectorLike[bool], Literal[0, 1, 2, 3, "0D", "1D", "2D", "3D", "preserve"]
| Control which dimensions will be modified by the filter.
| ``'preserve'`` is used by default.
|
| - Can be specified as a sequence of 3 boolean to allow modification on a per
| dimension basis.
| - ``0`` or ``'0D'``: convenience alias to output a 0D ImageData with
| dimensions ``(1, 1, 1)``. Only valid for 0D inputs.
| - ``1`` or ``'1D'``: convenience alias to output a 1D ImageData where
| exactly one dimension is greater than one, e.g. ``(>1, 1, 1)``. Only valid
| for 0D or 1D inputs.
| - ``2`` or ``'2D'``: convenience alias to output a 2D ImageData where
| exactly two dimensions are greater than one, e.g. ``(>1, >1, 1)``. Only
| valid for 0D, 1D, or 2D inputs.
| - ``3`` or ``'3D'``: convenience alias to output a 3D ImageData, where all
| three dimensions are greater than one, e.g. ``(>1, >1, >1)``. Valid for
| any 0D, 1D, 2D, or 3D inputs.
| - ``'preserve'`` (default): convenience alias to not modify singleton
| dimensions.
|
| copy : bool, default: True
| Copy the input point data before associating it with the output cell data.
| If ``False``, the input and output will both refer to the same data array(s).
|
| Returns
| -------
| pyvista.ImageData
| Image with a cell-based representation.
|
| Examples
| --------
| Load an image with point data.
|
| >>> from pyvista import examples
| >>> image = examples.load_uniform()
|
| Show the current properties and point arrays of the image.
|
| >>> image
| ImageData (...)
| N Cells: 729
| N Points: 1000
| X Bounds: 0.000e+00, 9.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| Dimensions: 10, 10, 10
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 2
|
| >>> image.point_data.keys()
| ['Spatial Point Data']
|
| Re-mesh the points and point data as cells and cell data.
|
| >>> cells_image = image.points_to_cells()
|
| Show the properties and cell arrays of the re-meshed image.
|
| >>> cells_image
| ImageData (...)
| N Cells: 1000
| N Points: 1331
| X Bounds: -5.000e-01, 9.500e+00
| Y Bounds: -5.000e-01, 9.500e+00
| Z Bounds: -5.000e-01, 9.500e+00
| Dimensions: 11, 11, 11
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> cells_image.cell_data.keys()
| ['Spatial Point Data']
|
| Observe that:
|
| - The input point array is now a cell array
| - The output has one less array (the input cell data is ignored)
| - The dimensions have increased by one
| - The bounds have increased by half the spacing
| - The output ``N Cells`` equals the input ``N Points``
|
| Since the input points are 3D (i.e. there are no singleton dimensions), the
| output cells are 3D :attr:`~pyvista.CellType.VOXEL` cells.
|
| >>> cells_image.get_cell(0).type
| <CellType.VOXEL: 11>
|
| If the input points are 2D (i.e. one dimension is singleton), the
| output cells are 2D :attr:`~pyvista.CellType.PIXEL` cells when ``dimensions`` is
| set to ``'preserve'``.
|
| >>> image2D = examples.download_beach()
| >>> image2D.dimensions
| (100, 100, 1)
|
| >>> pixel_cells_image = image2D.points_to_cells(dimensionality='preserve')
| >>> pixel_cells_image.dimensions
| (101, 101, 1)
| >>> pixel_cells_image.get_cell(0).type
| <CellType.PIXEL: 8>
|
| This is equivalent as requesting a 2D output.
|
| >>> pixel_cells_image = image2D.points_to_cells(dimensionality='2D')
| >>> pixel_cells_image.dimensions
| (101, 101, 1)
| >>> pixel_cells_image.get_cell(0).type
| <CellType.PIXEL: 8>
|
| Use ``(True, True, True)`` to re-mesh 2D points as 3D cells.
|
| >>> voxel_cells_image = image2D.points_to_cells(
| ... dimensionality=(True, True, True)
| ... )
| >>> voxel_cells_image.dimensions
| (101, 101, 2)
| >>> voxel_cells_image.get_cell(0).type
| <CellType.VOXEL: 11>
|
| Or request a 3D output.
|
| >>> voxel_cells_image = image2D.points_to_cells(dimensionality='3D')
| >>> voxel_cells_image.dimensions
| (101, 101, 2)
| >>> voxel_cells_image.get_cell(0).type
| <CellType.VOXEL: 11>
|
| See :ref:`image_representations_example` for more examples using this filter.
|
| resample(self: 'ImageData', sample_rate: 'float | VectorLike[float] | None' = None, interpolation: '_InterpolationOptions' = 'nearest', *, border_mode: "Literal['clamp', 'wrap', 'mirror']" = 'clamp', reference_image: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, anti_aliasing: 'bool' = False, extend_border: 'bool | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Resample the image to modify its dimensions and spacing.
|
| The resampling can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_image``.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``sample_rate`` explicitly.
|
| Use ``reference_image`` for full control of the resampled geometry. For
| all other options, the geometry is implicitly defined such that the resampled
| image fits the bounds of the input.
|
| This filter may be used to resample either point or cell data. For point data,
| this filter assumes the data is from discrete samples in space which represent
| pixels or voxels; the resampled bounds are therefore extended by 1/2 voxel
| spacing by default though this may be disabled.
|
| .. note::
|
| Singleton dimensions are not resampled by this filter, e.g. 2D images
| will remain 2D.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| sample_rate : float | VectorLike[float], optional
| Sampling rate(s) to use. Can be a single value or vector of three values
| for each axis. Values greater than ``1.0`` will up-sample the axis and
| values less than ``1.0`` will down-sample it. Values must be greater than ``0``.
|
| interpolation : 'nearest', 'linear', 'cubic', 'lanczos', 'hamming', 'blackman', 'bspline'
| Interpolation mode to use.
|
| - ``'nearest'`` (default) duplicates (if upsampling) or removes (if downsampling)
| values but does not modify them.
| - ``'linear'`` and ``'cubic'`` use linear and cubic interpolation, respectively.
| - ``'lanczos'``, ``'hamming'``, and ``'blackman'`` use a windowed sinc filter
| and may be used to preserve sharp details and/or reduce image artifacts.
| - ``'bspline'`` uses an n-degree basis spline to smoothly interpolate across points.
| The default degree is ``3``, but can range from ``0`` to ``9``. Append the desired
| degree to the string to set it, e.g. ``'bspline5'`` for a 5th-degree B-spline.
|
| .. versionadded:: 0.47
| Added ``'bspline'`` interpolation.
|
| .. note::
|
| - use ``'nearest'`` for pixel art or categorical data such as segmentation masks
| - use ``'linear'`` for speed-critical tasks
| - use ``'cubic'`` for upscaling or general-purpose resampling
| - use ``'lanczos'`` for high-detail downsampling (at the cost of some ringing)
| - use ``'blackman'`` for minimizing ringing artifacts (at the cost of some detail)
| - use ``'hamming'`` for a balance between detail-preservation and reducing ringing
|
| border_mode : 'clamp' | 'wrap' | 'mirror', default: 'clamp'
| Controls the interpolation at the image's borders.
|
| - ``'clamp'`` - values outside the image are clamped to the nearest edge.
| - ``'wrap'`` - values outside the image are wrapped periodically along the axis.
| - ``'mirror'`` - values outside the image are mirrored at the boundary.
|
| .. versionadded:: 0.47
|
| reference_image : ImageData, optional
| Reference image to use. If specified, the input is resampled
| to match the geometry of the reference. The :attr:`~pyvista.ImageData.dimensions`,
| :attr:`~pyvista.ImageData.spacing`, :attr:`~pyvista.ImageData.origin`,
| :attr:`~pyvista.ImageData.offset`, and :attr:`~pyvista.ImageData.direction_matrix`
| of the resampled image will all match the reference image.
|
| dimensions : VectorLike[int], optional
| Set the output :attr:`~pyvista.ImageData.dimensions` of the resampled image.
|
| .. note::
|
| Dimensions is the number of `points` along each axis. If resampling
| `cell` data, each dimension should be one more than the number of
| desired output cells (since there are ``N`` cells and ``N+1`` points
| along each axis). See examples.
|
| anti_aliasing : bool, default: False
| Enable antialiasing. This will blur the image as part of the resampling
| to reduce image artifacts when down-sampling. Has no effect when up-sampling.
|
| extend_border : bool, optional
| Extend the apparent input border by approximately half the
| :attr:`~pyvista.ImageData.spacing`. If enabled, the bounds of the
| resampled points will be larger than the input image bounds.
| Enabling this option also has the effect that the re-sampled spacing
| will directly correlate with the resampled dimensions, e.g. if
| the dimensions are doubled the spacing will be halved. See examples.
|
| This option is enabled by default when resampling point data. Has no effect
| when resampling cell data or when a ``reference_image`` is provided.
|
| scalars : str, optional
| Name of scalars to resample. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When scalars is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| inplace : bool, default: False
| If ``True``, resample the image inplace. By default, a new
| :class:`~pyvista.ImageData` instance is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Resampled image.
|
| See Also
| --------
| crop
| Crop image to remove points at the image's boundaries.
|
| :meth:`~pyvista.DataObjectFilters.sample`
| Resample array data from one mesh onto another.
|
| :meth:`~pyvista.DataSetFilters.interpolate`
| Interpolate values from one mesh onto another.
|
| :ref:`image_representations_example`
| Compare images represented as points vs. cells.
|
| Examples
| --------
| Create a small 2D grayscale image with dimensions ``3 x 2`` for demonstration.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> from pyvista import examples
| >>> image = pv.ImageData(dimensions=(3, 2, 1))
| >>> image.point_data['data'] = np.linspace(0, 255, 6, dtype=np.uint8)
|
| Define a custom plotter to show the image. Although the image data is defined
| as point data, we use :meth:`points_to_cells` to display the image as
| :attr:`~pyvista.CellType.PIXEL` (or :attr:`~pyvista.CellType.VOXEL`) cells
| instead. Grayscale coloring is used and the camera is adjusted to fit the image.
|
| >>> def image_plotter(image: pv.ImageData, clim=(0, 255)) -> pv.Plotter:
| ... pl = pv.Plotter()
| ... image = image.points_to_cells()
| ... pl.add_mesh(
| ... image,
| ... lighting=False,
| ... show_edges=True,
| ... cmap='grey',
| ... clim=clim,
| ... show_scalar_bar=False,
| ... line_width=3,
| ... )
| ... pl.view_xy()
| ... pl.camera.tight()
| ... pl.enable_anti_aliasing()
| ... return pl
|
| Show the image.
|
| >>> plot = image_plotter(image)
| >>> plot.show()
|
| Use ``sample_rate`` to up-sample the image. ``'nearest'`` interpolation is
| used by default.
|
| >>> upsampled = image.resample(sample_rate=2.0)
| >>> plot = image_plotter(upsampled)
| >>> plot.show()
|
| Use ``'linear'`` interpolation. Note that the argument names ``sample_rate``
| and ``interpolation`` may be omitted.
|
| >>> upsampled = image.resample(2.0, 'linear')
| >>> plot = image_plotter(upsampled)
| >>> plot.show()
|
| Use ``'cubic'`` interpolation. Here we also specify the output
| ``dimensions`` explicitly instead of using ``sample_rate``.
|
| >>> upsampled = image.resample(dimensions=(6, 4, 1), interpolation='cubic')
| >>> plot = image_plotter(upsampled)
| >>> plot.show()
|
| Compare the relative physical size of the image before and after resampling.
|
| >>> image
| ImageData (...)
| N Cells: 2
| N Points: 6
| X Bounds: 0.000e+00, 2.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 3, 2, 1
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> upsampled
| ImageData (...)
| N Cells: 15
| N Points: 24
| X Bounds: -2.500e-01, 2.250e+00
| Y Bounds: -2.500e-01, 1.250e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 6, 4, 1
| Spacing: 5.000e-01, 5.000e-01, 1.000e+00
| N Arrays: 1
|
| Note that the upsampled :attr:`~pyvista.ImageData.dimensions` are doubled and
| the :attr:`~pyvista.ImageData.spacing` is halved (as expected). Also note,
| however, that the physical bounds of the input differ from the output.
| The upsampled :attr:`~pyvista.ImageData.origin` also differs:
|
| >>> image.origin
| (0.0, 0.0, 0.0)
| >>> upsampled.origin
| (-0.25, -0.25, 0.0)
|
| This is because the resampling is done with ``extend_border`` enabled by default
| which adds a half cell-width border to the image and adjusts the origin and
| spacing such that the bounds match when the image is represented as cells.
|
| Apply :meth:`points_to_cells` to the input and resampled images and show that
| the bounds match.
|
| >>> image_as_cells = image.points_to_cells()
| >>> image_as_cells.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = 0.0,
| z_max = 0.0)
|
| >>> upsampled_as_cells = upsampled.points_to_cells()
| >>> upsampled_as_cells.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = 0.0,
| z_max = 0.0)
|
| Plot the two images together as wireframe to visualize them. The original is in
| red, and the resampled image is in black.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... image_as_cells, style='wireframe', color='red', line_width=10
| ... )
| >>> _ = pl.add_mesh(
| ... upsampled_as_cells, style='wireframe', color='black', line_width=2
| ... )
| >>> pl.view_xy()
| >>> pl.camera.tight()
| >>> pl.show()
|
| Disable ``extend_border`` to force the input and output bounds of the points
| to be the same instead.
|
| >>> upsampled = image.resample(sample_rate=2, extend_border=False)
|
| Compare the two images again.
|
| >>> image
| ImageData (...)
| N Cells: 2
| N Points: 6
| X Bounds: 0.000e+00, 2.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 3, 2, 1
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> upsampled
| ImageData (...)
| N Cells: 15
| N Points: 24
| X Bounds: 0.000e+00, 2.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 6, 4, 1
| Spacing: 4.000e-01, 3.333e-01, 1.000e+00
| N Arrays: 1
|
| This time the input and output bounds match without any further processing.
| Like before, the dimensions have doubled; unlike before, however, the spacing is
| not halved, but is instead smaller than half which is necessary to ensure the
| bounds remain the same. Also unlike before, the origin is unaffected:
|
| >>> image.origin
| (0.0, 0.0, 0.0)
| >>> upsampled.origin
| (0.0, 0.0, 0.0)
|
| All the above examples are with 2D images with point data. However, the filter
| also works with 3D volumes and will also work with cell data.
|
| Convert the 2D image with point data into a 3D volume with cell data and plot
| it for context.
|
| >>> volume = image.points_to_cells(dimensionality='3D')
| >>> volume.plot(show_edges=True, cmap='grey')
|
| Up-sample the volume. Set the sampling rate for each axis separately.
|
| >>> resampled = volume.resample(sample_rate=(3.0, 2.0, 1.0))
| >>> resampled.plot(show_edges=True, cmap='grey')
|
| Alternatively, we could have set the dimensions explicitly. Since we want
| ``9 x 4 x 1`` cells along the x-y-z axes (respectively), we set the dimensions
| to ``(10, 5, 2)``, i.e. one more than the desired number of cells.
|
| >>> resampled = volume.resample(dimensions=(10, 5, 2))
| >>> resampled.plot(show_edges=True, cmap='grey')
|
| Compare the bounds before and after resampling. Unlike with point data, the
| bounds are not (and cannot be) extended.
|
| >>> volume.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = -0.5,
| z_max = 0.5)
| >>> resampled.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = -0.5,
| z_max = 0.5)
|
| Use a reference image to control the resampling instead. Here we load two
| images with different dimensions:
| :func:`~pyvista.examples.downloads.download_bird` and
| :func:`~pyvista.examples.downloads.download_gourds`.
|
| >>> bird = examples.download_bird()
| >>> bird.dimensions
| (458, 342, 1)
|
| >>> gourds = examples.download_gourds()
| >>> gourds.dimensions
| (640, 480, 1)
|
| Use ``reference_image`` to resample the bird to match the gourds geometry or
| vice-versa.
|
| >>> bird_resampled = bird.resample(reference_image=gourds)
| >>> bird_resampled.dimensions
| (640, 480, 1)
|
| >>> gourds_resampled = gourds.resample(reference_image=bird)
| >>> gourds_resampled.dimensions
| (458, 342, 1)
|
| Downsample the gourds image to 1/10th its original resolution using ``'lanczos'``
| interpolation.
|
| >>> downsampled = gourds.resample(1 / 8, 'lanczos')
| >>> downsampled.dimensions
| (80, 60, 1)
|
| Compare the downsampled image to the original and zoom in to show detail.
|
| >>> def compare_images_plotter(image1, image2):
| ... pl = pv.Plotter(shape=(1, 2))
| ... _ = pl.add_mesh(image1, rgba=True, show_edges=False, lighting=False)
| ... pl.subplot(0, 1)
| ... _ = pl.add_mesh(image2, rgba=True, show_edges=False, lighting=False)
| ... pl.link_views()
| ... pl.view_xy()
| ... pl.camera.zoom(3.0)
| ... return pl
|
| >>> pl = compare_images_plotter(gourds, downsampled)
| >>> pl.show()
|
| Note that downsampling can create image artifacts caused by aliasing. Enable
| anti-aliasing to smooth the image before resampling.
|
| >>> downsampled2 = gourds.resample(1 / 8, 'lanczos', anti_aliasing=True)
|
| Compare down-sampling with aliasing (left) to without aliasing (right).
|
| >>> pl = compare_images_plotter(downsampled, downsampled2)
| >>> pl.show()
|
| Load an MRI of a knee and downsample it.
|
| >>> knee = pv.examples.download_knee().resample(
| ... 0.1, 'linear', anti_aliasing=True
| ... )
|
| Crop and plot it.
|
| >>> knee = knee.crop(normalized_bounds=[0.2, 0.8, 0.2, 0.8, 0.0, 1.0])
| >>> vmin = knee.active_scalars.min()
| >>> vmax = knee.active_scalars.max()
| >>> pl = image_plotter(knee, clim=[vmin, vmax])
| >>> pl.show()
|
| Upsample it with B-spline interpolation. The interpolation is very smooth.
|
| >>> upsampled = knee.resample(2.0, 'bspline', border_mode='clamp')
| >>> pl = image_plotter(upsampled, clim=[vmin, vmax])
| >>> pl.show()
|
| Use the ``'wrap'`` border mode. Note how points at the border are brighter than previously,
| since the bright pixels from the opposite edge are now included in the interpolation.
|
| >>> upsampled = knee.resample(2.0, 'bspline', border_mode='wrap')
| >>> pl = image_plotter(upsampled, clim=[vmin, vmax])
| >>> pl.show()
|
| Compare B-spline interpolation to ``'hamming'``.
|
| >>> upsampled = knee.resample(2.0, 'hamming')
| >>> pl = image_plotter(upsampled, clim=[vmin, vmax])
| >>> pl.show()
|
| rfft(self, output_scalars_name=None, progress_bar: 'bool' = False)
| Apply a reverse fast Fourier transform (RFFT) to the active scalars.
|
| The input can be real or complex data, but the output is always
| :attr:`numpy.complex128`. The filter is fastest for images that have power
| of two sizes.
|
| The filter uses a butterfly diagram for each prime factor of the
| dimension. This makes images with prime number dimensions (i.e. 17x17)
| much slower to compute. FFTs of multidimensional meshes (i.e volumes)
| are decomposed so that each axis executes serially.
|
| The frequencies of the input assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with the applied reverse FFT.
|
| See Also
| --------
| fft : The direct transform.
| low_pass : Low-pass filtering of FFT output.
| high_pass : High-pass filtering of FFT output.
|
| Examples
| --------
| Apply reverse FFT to an example image.
|
| >>> from pyvista import examples
| >>> image = examples.download_moonlanding_image()
| >>> fft_image = image.fft()
| >>> image_again = fft_image.rfft()
| >>> image_again.point_data # doctest:+SKIP
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : PNGImage
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| PNGImage complex128 (298620,) SCALARS
|
| See :ref:`image_fft_example` for a full example using this filter.
|
| select_values(self: 'ImageData', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, fill_value: 'float | VectorLike[float]' = 0, replacement_value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, split: 'bool' = False)
| Select values of interest and fill the rest with a constant.
|
| Point or cell data may be selected with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to select a single label or groups
| of labels from categorical data, or to select multiple regions from continuous
| data. Selected values may optionally be split into separate meshes.
|
| The selected values are stored in an array with the same name as the input.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to select. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When selecting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to select. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| selection. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to select values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to select values less than or equal to zero.
|
| fill_value : float | VectorLike[float] | None, default: 0
| Value used to fill the image. Can be a single value or a multi-component
| vector. Non-selected parts of the image will have this value. Set this to
| ``None`` to keep the input array's original values for non-selected regions.
|
| replacement_value : float | VectorLike[float], optional
| Replacement value for the output array. Can be a single value or a
| multi-component vector. If provided, selected values will be replaced with
| the given value. If no value is given, the selected values are retained and
| returned as-is. Setting this value is useful for generating a binarized
| output array.
|
| scalars : str, optional
| Name of scalars to select from. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the selection. If ``True`` values are selected which do *not* have
| the specified values.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| selected independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain meshes with only the ``fill_value`` if no
| values meet the selection criteria.
|
| See Also
| --------
| image_threshold
| Similar filter for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Similar threshold-like filter for extracting values from any dataset.
| :meth:`~pyvista.DataSetFilters.split_values`
| Split a mesh by value into separate meshes.
| :meth:`~pyvista.DataSetFilters.threshold`
| Generalized thresholding filter which returns a :class:`~pyvista.UnstructuredGrid`.
|
| Returns
| -------
| output : pyvista.ImageData | pyvista.MultiBlock
| Image with selected values or a composite of meshes with selected
| values, depending on ``split``.
|
| Examples
| --------
| Load a CT image. Here we load
| :func:`~pyvista.examples.downloads.download_whole_body_ct_male`.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.download_whole_body_ct_male()
| >>> ct_image = dataset['ct']
|
| Show the initial data range.
|
| >>> ct_image.get_data_range()
| (np.int16(-1348), np.int16(3409))
|
| Select intensity values above ``150`` to select the bones.
|
| >>> bone_range = [150, float('inf')]
| >>> fill_value = -1000 # fill with intensity values corresponding to air
| >>> bone_image = ct_image.select_values(
| ... ranges=bone_range, fill_value=fill_value
| ... )
|
| Show the new data range.
|
| >>> bone_image.get_data_range()
| (np.int16(-1000), np.int16(3409))
|
| Plot the selected values. Use ``'foreground'`` opacity to make the fill value
| transparent and the selected values opaque.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_volume(
| ... bone_image,
| ... opacity='foreground',
| ... cmap='bone',
| ... )
| >>> pl.view_zx()
| >>> pl.camera.up = (0, 0, 1)
| >>> pl.show()
|
| Use ``'replacement_value'`` to binarize the selected values instead. The fill
| value, or background, is ``0`` by default.
|
| >>> bone_mask = ct_image.select_values(ranges=bone_range, replacement_value=1)
| >>> bone_mask.get_data_range()
| (np.int16(0), np.int16(1))
|
| Generate a surface contour of the mask and plot it.
|
| >>> surf = bone_mask.contour_labels()
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(surf, color=True)
| >>> pl.view_zx()
| >>> pl.camera.up = (0, 0, 1)
| >>> pl.show()
|
| Load a color image. Here we load :func:`~pyvista.examples.downloads.download_beach`.
|
| >>> image = examples.download_beach()
| >>> plot_kwargs = dict(
| ... cpos='xy', rgb=True, lighting=False, zoom='tight', show_axes=False
| ... )
| >>> image.plot(**plot_kwargs)
|
| Select components from the image which have a strong red component.
| Use ``replacement_value`` to replace these pixels with a pure red color
| and ``fill_value`` to fill the rest of the image with white pixels.
|
| >>> white = [255, 255, 255]
| >>> red = [255, 0, 0]
| >>> red_range = [200, 255]
| >>> red_component = 0
| >>> selected = image.select_values(
| ... ranges=red_range,
| ... component_mode=red_component,
| ... replacement_value=red,
| ... fill_value=white,
| ... )
|
| >>> selected.plot(**plot_kwargs)
|
| slice_index(self: 'ImageData', i: 'int | VectorLike[int] | slice | None' = None, j: 'int | VectorLike[int] | slice | None' = None, k: 'int | VectorLike[int] | slice | None' = None, *, index_mode: "Literal['extent', 'dimensions']" = 'dimensions', strict_index: 'bool' = False, rebase_coordinates: 'bool' = False, progress_bar: 'bool' = False) -> 'ImageData'
| Extract a subset using IJK indices.
|
| This filter enables slicing :class:`~pyvista.ImageData` with Python-style indexing using
| IJK coordinates. It can be used to extract a single slice, multiple contiguous slices, or
| a volume of interest. Unlike other slicing filters, this filter returns
| :class:`~pyvista.ImageData`.
|
| .. note::
| Slicing by index is also possible using the "get index" operator ``[]``. See examples.
|
| .. versionadded::0.46
|
| Parameters
| ----------
| i, j, k : int | VectorLike[int] | slice, optional
| Indices to slice along the I, J, and K coordinate axes, respectively. Specify an
| integer for a single index, or two integers ``[start, stop)`` for a range of indices.
|
| .. note::
|
| Like regular Python slicing:
|
| - Half-open intervals are used, i.e. the ``start`` index is included in the range
| but the ``stop`` index is not.
| - Negative indexing is supported.
| - An ``IndexError`` is raised when a single integer is specified as the index and
| the index is out-of-bounds.
| - An ``IndexError`` is `not` raised when a range is specified as the index and
| the index is out-of-bounds. This default can be overridden by setting
| ``strict_index=True``.
| - A copy of the data is returned (modifying the sliced output does `not` affect
| the input data).
|
| index_mode : 'extent' | 'dimensions', default: 'dimensions'
| Mode to use when determining the range of values to index from.
|
| - Use ``'dimensions'`` to index values in the range ``[0, dimensions - 1]``.
| - Use ``'extent'`` to index values based on the :class:`~pyvista.ImageData.extent`,
| i.e. ``[offset, offset + dimensions - 1]``.
|
| The main difference between these modes is the inclusion or exclusion of the
| :attr:`~pyvista.ImageData.offset`. ``dimensions`` is more pythonic and is how the
| object's data arrays themselves would be indexed, whereas ``'extent'`` respects VTK's
| definition of ``extent`` and considers the object's geometry.
|
| strict_index : bool, default: False
| Raise an ``IndexError`` if `any` of the indices are out of range. By default, an
| ``IndexError`` is only raised if a single integer index is out of range, but not when
| a range of indices are specified; set this to ``True`` to raise in error in both cases.
|
| rebase_coordinates : bool, default: False
| Rebase the coordinate reference of the extracted subset:
|
| - the :attr:`~pyvista.ImageData.origin` is set to the minimum bounds of the subset
| - the :attr:`~pyvista.ImageData.offset` is reset to ``(0, 0, 0)``
|
| The rebasing effectively applies a positive translation in world (XYZ) coordinates and
| a similar (i.e. inverse) negative translation in voxel (IJK) coordinates. As a result,
| the :attr:`~pyvista.DataSet.bounds` of the output are unchanged, but the coordinate
| reference frame is modified.
|
| Set this to ``False`` to leave the origin unmodified and keep the offset specified by
| the indexing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Sliced mesh.
|
| See Also
| --------
| crop
| extract_subset
| :meth:`~pyvista.DataObjectFilters.slice`
| :meth:`~pyvista.DataObjectFilters.slice_implicit`
| :meth:`~pyvista.DataObjectFilters.slice_orthogonal`
| :meth:`~pyvista.DataObjectFilters.slice_along_axis`
| :meth:`~pyvista.DataObjectFilters.slice_along_line`
|
| Examples
| --------
| Create a :class:`~pyvista.ImageData` mesh and give it some point data.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(10, 10, 10))
| >>> mesh['data'] = range(mesh.n_points)
|
| Extract a single slice along the k-axis.
|
| >>> sliced = mesh.slice_index(k=5)
| >>> sliced.dimensions
| (10, 10, 1)
|
| Equivalently:
|
| >>> sliced2 = mesh[:, :, 5]
| >>> sliced == sliced2
| True
|
| Extract a volume of interest.
|
| >>> sliced = mesh.slice_index(i=[1, 3], j=[2, 5], k=[5, 10])
| >>> sliced.dimensions
| (2, 3, 5)
|
| Equivalently:
|
| >>> sliced2 = mesh[1:3, 2:5, 5:10]
| >>> sliced == sliced2
| True
|
| Use ``None`` to implicitly define the start and/or stop indices.
|
| >>> sliced = mesh.slice_index(i=[None, 3], j=[2, None], k=None)
| >>> sliced.dimensions
| (3, 8, 10)
|
| Equivalently:
|
| >>> sliced2 = mesh[:3, 2:, :]
| >>> sliced == sliced2
| True
|
| See :ref:`slice_example` for more examples using this filter.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
pyvista.ImageEllipsoidSource
Python Library Documentation: class ImageEllipsoidSource in module pyvista.core.utilities.image_sources
class ImageEllipsoidSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageEllipsoidSource)
| ImageEllipsoidSource(*args, **kwargs) -> '_T'
|
| Create a binary image of an ellipsoid class.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| whole_extent : sequence[int]
| The extent of the whole output image.
|
| center : sequence[float]
| The center of the ellipsoid.
|
| radius : tuple
| The radius of the ellipsoid.
|
| Examples
| --------
| Create an image of an ellipsoid.
|
| >>> import pyvista as pv
| >>> source = pv.ImageEllipsoidSource(
| ... whole_extent=(0, 20, 0, 20, 0, 0),
| ... center=(10, 10, 0),
| ... radius=(3, 4, 5),
| ... )
| >>> source.output.plot(cpos='xy')
|
| Method resolution order:
| ImageEllipsoidSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkImagingSources.vtkImageEllipsoidSource
| vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, whole_extent=None, center=None, radius=None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output image as a ImageData.
|
| Returns
| -------
| pyvista.ImageData
| The output image.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Get the center of the ellipsoid.
|
| Returns
| -------
| tuple[float, float, float]
| The center of the ellipsoid.
|
| radius
| Get the radius of the ellipsoid.
|
| Returns
| -------
| sequence[float]
| The radius of the ellipsoid.
|
| whole_extent
| Get extent of the whole output image.
|
| Returns
| -------
| sequence[int]
| The extent of the whole output image.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkImagingSources.vtkImageEllipsoidSource:
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetInValue(...)
| GetInValue(self) -> float
| C++: virtual double GetInValue()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutValue(...)
| GetOutValue(self) -> float
| C++: virtual double GetOutValue()
|
| GetOutputScalarType(...)
| GetOutputScalarType(self) -> int
| C++: virtual int GetOutputScalarType()
|
| GetRadius(...)
| GetRadius(self) -> (float, float, float)
| C++: virtual double *GetRadius()
|
| GetWholeExtent(...)
| GetWholeExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetWholeExtent(int extent[6])
| GetWholeExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetWholeExtent()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkImageEllipsoidSource
| C++: vtkImageEllipsoidSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkImageEllipsoidSource
| C++: static vtkImageEllipsoidSource *SafeDownCast(
| vtkObjectBase *o)
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set/Get the center of the ellipsoid.
|
| SetInValue(...)
| SetInValue(self, _arg:float) -> None
| C++: virtual void SetInValue(double _arg)
|
| Set/Get the inside pixel values.
|
| SetOutValue(...)
| SetOutValue(self, _arg:float) -> None
| C++: virtual void SetOutValue(double _arg)
|
| Set/Get the outside pixel values.
|
| SetOutputScalarType(...)
| SetOutputScalarType(self, _arg:int) -> None
| C++: virtual void SetOutputScalarType(int _arg)
|
| Set what type of scalar data this source should generate.
|
| SetOutputScalarTypeToChar(...)
| SetOutputScalarTypeToChar(self) -> None
| C++: void SetOutputScalarTypeToChar()
|
| SetOutputScalarTypeToDouble(...)
| SetOutputScalarTypeToDouble(self) -> None
| C++: void SetOutputScalarTypeToDouble()
|
| SetOutputScalarTypeToFloat(...)
| SetOutputScalarTypeToFloat(self) -> None
| C++: void SetOutputScalarTypeToFloat()
|
| SetOutputScalarTypeToInt(...)
| SetOutputScalarTypeToInt(self) -> None
| C++: void SetOutputScalarTypeToInt()
|
| SetOutputScalarTypeToLong(...)
| SetOutputScalarTypeToLong(self) -> None
| C++: void SetOutputScalarTypeToLong()
|
| SetOutputScalarTypeToShort(...)
| SetOutputScalarTypeToShort(self) -> None
| C++: void SetOutputScalarTypeToShort()
|
| SetOutputScalarTypeToUnsignedChar(...)
| SetOutputScalarTypeToUnsignedChar(self) -> None
| C++: void SetOutputScalarTypeToUnsignedChar()
|
| SetOutputScalarTypeToUnsignedInt(...)
| SetOutputScalarTypeToUnsignedInt(self) -> None
| C++: void SetOutputScalarTypeToUnsignedInt()
|
| SetOutputScalarTypeToUnsignedLong(...)
| SetOutputScalarTypeToUnsignedLong(self) -> None
| C++: void SetOutputScalarTypeToUnsignedLong()
|
| SetOutputScalarTypeToUnsignedShort(...)
| SetOutputScalarTypeToUnsignedShort(self) -> None
| C++: void SetOutputScalarTypeToUnsignedShort()
|
| SetRadius(...)
| SetRadius(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetRadius(double _arg1, double _arg2,
| double _arg3)
| SetRadius(self, _arg:(float, float, float)) -> None
| C++: virtual void SetRadius(const double _arg[3])
|
| Set/Get the radius of the ellipsoid.
|
| SetWholeExtent(...)
| SetWholeExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void SetWholeExtent(int extent[6])
| SetWholeExtent(self, minX:int, maxX:int, minY:int, maxY:int,
| minZ:int, maxZ:int) -> None
| C++: void SetWholeExtent(int minX, int maxX, int minY, int maxY,
| int minZ, int maxZ)
|
| Set/Get the extent of the whole output image.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkImagingSources.vtkImageEllipsoidSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkImagingSources.vtkImageEllipsoidSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkImagingSources.vtkImageEllipsoidSource:
|
| __this__
| Pointer to the C++ object.
|
| in_value
| read-write, calls GetInValue/SetInValue
|
| out_value
| read-write, calls GetOutValue/SetOutValue
|
| output_scalar_type
| read-write, calls GetOutputScalarType/SetOutputScalarType
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkImagingSources.vtkImageEllipsoidSource:
|
| __vtkname__ = 'vtkImageEllipsoidSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: virtual void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: virtual void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| GetImageDataInput(...)
| GetImageDataInput(self, port:int) -> vtkImageData
| C++: vtkImageData *GetImageDataInput(int port)
|
| GetInput(...)
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
|
| Get a data object for one of the input port connections. The use
| of this method is strongly discouraged, but some filters that
| were written a long time ago still use this method.
|
| GetOutput(...)
| GetOutput(self) -> vtkImageData
| C++: vtkImageData *GetOutput()
| GetOutput(self, __a:int) -> vtkImageData
| C++: vtkImageData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.ImageGaussianSource
Python Library Documentation: class ImageGaussianSource in module pyvista.core.utilities.image_sources
class ImageGaussianSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageGaussianSource)
| ImageGaussianSource(*args, **kwargs) -> '_T'
|
| Create a binary image with Gaussian pixel values.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| center : sequence[float]
| The center of the gaussian.
|
| whole_extent : sequence[int]
| The extent of the whole output image.
|
| maximum : float
| The maximum value of the gaussian.
|
| std : sequence[float]
| The standard deviation of the gaussian.
|
| Examples
| --------
| Create an image of Gaussian pixel values.
|
| >>> import pyvista as pv
| >>> source = pv.ImageGaussianSource(
| ... center=(100, 100, 0),
| ... whole_extent=(0, 200, 0, 200, 0, 0),
| ... maximum=255,
| ... std=100.0,
| ... )
| >>> source.output.plot(cpos='xy')
|
| Method resolution order:
| ImageGaussianSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkImagingSources.vtkImageGaussianSource
| vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, center=None, whole_extent=None, maximum=None, std=None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output image as a ImageData.
|
| Returns
| -------
| pyvista.ImageData
| The output image.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Get the center of the gaussian.
|
| Returns
| -------
| tuple[float, float, float]
| The center of the gaussian.
|
| maximum
| Get the maximum value of the gaussian.
|
| Returns
| -------
| float
| The maximum value of the gaussian.
|
| std
| Get the standard deviation of the gaussian.
|
| Returns
| -------
| float
| The standard deviation of the gaussian.
|
| whole_extent
| Get extent of the whole output image.
|
| Returns
| -------
| sequence[int]
| The extent of the whole output image.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkImagingSources.vtkImageGaussianSource:
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetMaximum(...)
| GetMaximum(self) -> float
| C++: virtual double GetMaximum()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetStandardDeviation(...)
| GetStandardDeviation(self) -> float
| C++: virtual double GetStandardDeviation()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkImageGaussianSource
| C++: vtkImageGaussianSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkImageGaussianSource
| C++: static vtkImageGaussianSource *SafeDownCast(vtkObjectBase *o)
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set/Get the center of the Gaussian.
|
| SetMaximum(...)
| SetMaximum(self, _arg:float) -> None
| C++: virtual void SetMaximum(double _arg)
|
| Set/Get the Maximum value of the gaussian
|
| SetStandardDeviation(...)
| SetStandardDeviation(self, _arg:float) -> None
| C++: virtual void SetStandardDeviation(double _arg)
|
| Set/Get the standard deviation of the gaussian
|
| SetWholeExtent(...)
| SetWholeExtent(self, xMin:int, xMax:int, yMin:int, yMax:int,
| zMin:int, zMax:int) -> None
| C++: void SetWholeExtent(int xMin, int xMax, int yMin, int yMax,
| int zMin, int zMax)
|
| Set/Get the extent of the whole output image.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkImagingSources.vtkImageGaussianSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkImagingSources.vtkImageGaussianSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkImagingSources.vtkImageGaussianSource:
|
| __this__
| Pointer to the C++ object.
|
| standard_deviation
| read-write, calls GetStandardDeviation/SetStandardDeviation
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkImagingSources.vtkImageGaussianSource:
|
| __vtkname__ = 'vtkImageGaussianSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: virtual void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: virtual void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| GetImageDataInput(...)
| GetImageDataInput(self, port:int) -> vtkImageData
| C++: vtkImageData *GetImageDataInput(int port)
|
| GetInput(...)
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
|
| Get a data object for one of the input port connections. The use
| of this method is strongly discouraged, but some filters that
| were written a long time ago still use this method.
|
| GetOutput(...)
| GetOutput(self) -> vtkImageData
| C++: vtkImageData *GetOutput()
| GetOutput(self, __a:int) -> vtkImageData
| C++: vtkImageData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.ImageGridSource
Python Library Documentation: class ImageGridSource in module pyvista.core.utilities.image_sources
class ImageGridSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageGridSource)
| ImageGridSource(*args, **kwargs) -> '_T'
|
| Create an image of a grid.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| origin : sequence[float]
| The origin of the grid.
|
| extent : sequence[int]
| The extent of the whole output image, Default: (0,255,0,255,0,0).
|
| spacing : tuple
| The pixel spacing.
|
| Examples
| --------
| Create an image of a grid.
|
| >>> import pyvista as pv
| >>> source = pv.ImageGridSource(
| ... extent=(0, 20, 0, 20, 0, 0),
| ... spacing=(1, 1, 1),
| ... )
| >>> source.output.plot(cpos='xy')
|
| Method resolution order:
| ImageGridSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkImagingSources.vtkImageGridSource
| vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, origin=None, extent=None, spacing=None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output image as a ImageData.
|
| Returns
| -------
| pyvista.ImageData
| The output image.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| extent
| Get extent of the whole output image.
|
| Returns
| -------
| sequence[int]
| The extent of the whole output image.
|
| origin
| Get the origin of the data.
|
| Returns
| -------
| sequence[float]
| The origin of the grid.
|
| spacing
| Get the spacing of the grid.
|
| Returns
| -------
| sequence[float]
| The pixel spacing.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkImagingSources.vtkImageGridSource:
|
| GetDataExtent(...)
| GetDataExtent(self) -> (int, int, int, int, int, int)
| C++: virtual int *GetDataExtent()
|
| GetDataOrigin(...)
| GetDataOrigin(self) -> (float, float, float)
| C++: virtual double *GetDataOrigin()
|
| GetDataScalarType(...)
| GetDataScalarType(self) -> int
| C++: virtual int GetDataScalarType()
|
| GetDataScalarTypeAsString(...)
| GetDataScalarTypeAsString(self) -> str
| C++: const char *GetDataScalarTypeAsString()
|
| GetDataSpacing(...)
| GetDataSpacing(self) -> (float, float, float)
| C++: virtual double *GetDataSpacing()
|
| GetFillValue(...)
| GetFillValue(self) -> float
| C++: virtual double GetFillValue()
|
| GetGridOrigin(...)
| GetGridOrigin(self) -> (int, int, int)
| C++: virtual int *GetGridOrigin()
|
| GetGridSpacing(...)
| GetGridSpacing(self) -> (int, int, int)
| C++: virtual int *GetGridSpacing()
|
| GetLineValue(...)
| GetLineValue(self) -> float
| C++: virtual double GetLineValue()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkImageGridSource
| C++: vtkImageGridSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkImageGridSource
| C++: static vtkImageGridSource *SafeDownCast(vtkObjectBase *o)
|
| SetDataExtent(...)
| SetDataExtent(self, _arg1:int, _arg2:int, _arg3:int, _arg4:int,
| _arg5:int, _arg6:int) -> None
| C++: virtual void SetDataExtent(int _arg1, int _arg2, int _arg3,
| int _arg4, int _arg5, int _arg6)
| SetDataExtent(self, _arg:(int, int, int, int, int, int)) -> None
| C++: virtual void SetDataExtent(const int _arg[6])
|
| Set/Get the extent of the whole output image, Default:
| (0,255,0,255,0,0)
|
| SetDataOrigin(...)
| SetDataOrigin(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetDataOrigin(double _arg1, double _arg2,
| double _arg3)
| SetDataOrigin(self, _arg:(float, float, float)) -> None
| C++: virtual void SetDataOrigin(const double _arg[3])
|
| Set/Get the origin of the data.
|
| SetDataScalarType(...)
| SetDataScalarType(self, _arg:int) -> None
| C++: virtual void SetDataScalarType(int _arg)
|
| Set/Get the data type of pixels in the imported data. As a
| convenience, the OutputScalarType is set to the same value.
|
| SetDataScalarTypeToDouble(...)
| SetDataScalarTypeToDouble(self) -> None
| C++: void SetDataScalarTypeToDouble()
|
| SetDataScalarTypeToInt(...)
| SetDataScalarTypeToInt(self) -> None
| C++: void SetDataScalarTypeToInt()
|
| SetDataScalarTypeToShort(...)
| SetDataScalarTypeToShort(self) -> None
| C++: void SetDataScalarTypeToShort()
|
| SetDataScalarTypeToUnsignedChar(...)
| SetDataScalarTypeToUnsignedChar(self) -> None
| C++: void SetDataScalarTypeToUnsignedChar()
|
| SetDataScalarTypeToUnsignedShort(...)
| SetDataScalarTypeToUnsignedShort(self) -> None
| C++: void SetDataScalarTypeToUnsignedShort()
|
| SetDataSpacing(...)
| SetDataSpacing(self, _arg1:float, _arg2:float, _arg3:float)
| -> None
| C++: virtual void SetDataSpacing(double _arg1, double _arg2,
| double _arg3)
| SetDataSpacing(self, _arg:(float, float, float)) -> None
| C++: virtual void SetDataSpacing(const double _arg[3])
|
| Set/Get the pixel spacing.
|
| SetFillValue(...)
| SetFillValue(self, _arg:float) -> None
| C++: virtual void SetFillValue(double _arg)
|
| Set the grey level of the fill. Default 0.0.
|
| SetGridOrigin(...)
| SetGridOrigin(self, _arg1:int, _arg2:int, _arg3:int) -> None
| C++: virtual void SetGridOrigin(int _arg1, int _arg2, int _arg3)
| SetGridOrigin(self, _arg:(int, int, int)) -> None
| C++: virtual void SetGridOrigin(const int _arg[3])
|
| Set/Get the grid origin, in ijk integer values. Default (0,0,0).
|
| SetGridSpacing(...)
| SetGridSpacing(self, _arg1:int, _arg2:int, _arg3:int) -> None
| C++: virtual void SetGridSpacing(int _arg1, int _arg2, int _arg3)
| SetGridSpacing(self, _arg:(int, int, int)) -> None
| C++: virtual void SetGridSpacing(const int _arg[3])
|
| Set/Get the grid spacing in pixel units. Default (10,10,0). A
| value of zero means no grid.
|
| SetLineValue(...)
| SetLineValue(self, _arg:float) -> None
| C++: virtual void SetLineValue(double _arg)
|
| Set the grey level of the lines. Default 1.0.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkImagingSources.vtkImageGridSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkImagingSources.vtkImageGridSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkImagingSources.vtkImageGridSource:
|
| __this__
| Pointer to the C++ object.
|
| data_extent
| read-write, calls GetDataExtent/SetDataExtent
|
| data_origin
| read-write, calls GetDataOrigin/SetDataOrigin
|
| data_scalar_type
| read-write, calls GetDataScalarType/SetDataScalarType
|
| data_spacing
| read-write, calls GetDataSpacing/SetDataSpacing
|
| fill_value
| read-write, calls GetFillValue/SetFillValue
|
| grid_origin
| read-write, calls GetGridOrigin/SetGridOrigin
|
| grid_spacing
| read-write, calls GetGridSpacing/SetGridSpacing
|
| line_value
| read-write, calls GetLineValue/SetLineValue
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkImagingSources.vtkImageGridSource:
|
| __vtkname__ = 'vtkImageGridSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: virtual void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: virtual void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| GetImageDataInput(...)
| GetImageDataInput(self, port:int) -> vtkImageData
| C++: vtkImageData *GetImageDataInput(int port)
|
| GetInput(...)
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
|
| Get a data object for one of the input port connections. The use
| of this method is strongly discouraged, but some filters that
| were written a long time ago still use this method.
|
| GetOutput(...)
| GetOutput(self) -> vtkImageData
| C++: vtkImageData *GetOutput()
| GetOutput(self, __a:int) -> vtkImageData
| C++: vtkImageData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.ImageMandelbrotSource
Python Library Documentation: class ImageMandelbrotSource in module pyvista.core.utilities.image_sources
class ImageMandelbrotSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageMandelbrotSource)
| ImageMandelbrotSource(*args, **kwargs) -> '_T'
|
| Create an image of the Mandelbrot set.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| whole_extent : sequence[int]
| The extent of the whole output image.
|
| maxiter : int
| The maximum number of iterations.
|
| Examples
| --------
| Create an image of the Mandelbrot set.
|
| >>> import pyvista as pv
| >>> source = pv.ImageMandelbrotSource(
| ... whole_extent=(0, 200, 0, 200, 0, 0),
| ... maxiter=100,
| ... )
| >>> source.output.plot(cpos='xy')
|
| Method resolution order:
| ImageMandelbrotSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkImagingSources.vtkImageMandelbrotSource
| vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, whole_extent=None, maxiter=None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output image as a ImageData.
|
| Returns
| -------
| pyvista.ImageData
| The output image.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| maxiter
| Get the maximum number of iterations.
|
| Returns
| -------
| int
| The maximum number of iterations.
|
| whole_extent
| Get extent of the whole output image.
|
| Returns
| -------
| sequence[int]
| The extent of the whole output image.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkImagingSources.vtkImageMandelbrotSource:
|
| ConstantSizeOff(...)
| ConstantSizeOff(self) -> None
| C++: virtual void ConstantSizeOff()
|
| ConstantSizeOn(...)
| ConstantSizeOn(self) -> None
| C++: virtual void ConstantSizeOn()
|
| CopyOriginAndSample(...)
| CopyOriginAndSample(self, source:vtkImageMandelbrotSource) -> None
| C++: void CopyOriginAndSample(vtkImageMandelbrotSource *source)
|
| Convenience for Viewer. Copy the OriginCX and the SpacingCX.
| What about other parameters ???
|
| GetConstantSize(...)
| GetConstantSize(self) -> int
| C++: virtual vtkTypeBool GetConstantSize()
|
| GetMaximumNumberOfIterations(...)
| GetMaximumNumberOfIterations(self) -> int
| C++: virtual unsigned short GetMaximumNumberOfIterations()
|
| GetMaximumNumberOfIterationsMaxValue(...)
| GetMaximumNumberOfIterationsMaxValue(self) -> int
| C++: virtual unsigned short GetMaximumNumberOfIterationsMaxValue()
|
| GetMaximumNumberOfIterationsMinValue(...)
| GetMaximumNumberOfIterationsMinValue(self) -> int
| C++: virtual unsigned short GetMaximumNumberOfIterationsMinValue()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOriginCX(...)
| GetOriginCX(self) -> (float, float, float, float)
| C++: virtual double *GetOriginCX()
|
| GetProjectionAxes(...)
| GetProjectionAxes(self) -> (int, int, int)
| C++: virtual int *GetProjectionAxes()
|
| GetSampleCX(...)
| GetSampleCX(self) -> (float, float, float, float)
| C++: virtual double *GetSampleCX()
|
| GetSizeCX(...)
| GetSizeCX(self) -> (float, float, float, float)
| C++: double *GetSizeCX()
| GetSizeCX(self, s:[float, float, float, float]) -> None
| C++: void GetSizeCX(double s[4])
|
| GetSubsampleRate(...)
| GetSubsampleRate(self) -> int
| C++: virtual int GetSubsampleRate()
|
| GetSubsampleRateMaxValue(...)
| GetSubsampleRateMaxValue(self) -> int
| C++: virtual int GetSubsampleRateMaxValue()
|
| GetSubsampleRateMinValue(...)
| GetSubsampleRateMinValue(self) -> int
| C++: virtual int GetSubsampleRateMinValue()
|
| GetWholeExtent(...)
| GetWholeExtent(self) -> (int, int, int, int, int, int)
| C++: virtual int *GetWholeExtent()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkImageMandelbrotSource
| C++: vtkImageMandelbrotSource *NewInstance()
|
| Pan(...)
| Pan(self, x:float, y:float, z:float) -> None
| C++: void Pan(double x, double y, double z)
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkImageMandelbrotSource
| C++: static vtkImageMandelbrotSource *SafeDownCast(
| vtkObjectBase *o)
|
| SetConstantSize(...)
| SetConstantSize(self, _arg:int) -> None
| C++: virtual void SetConstantSize(vtkTypeBool _arg)
|
| This flag determines whether the Size or spacing of a data set
| remain constant (when extent is changed). By default, size
| remains constant.
|
| SetMaximumNumberOfIterations(...)
| SetMaximumNumberOfIterations(self, _arg:int) -> None
| C++: virtual void SetMaximumNumberOfIterations(
| unsigned short _arg)
|
| The maximum number of cycles run to see if the value goes over 2
|
| SetOriginCX(...)
| SetOriginCX(self, _arg1:float, _arg2:float, _arg3:float,
| _arg4:float) -> None
| C++: virtual void SetOriginCX(double _arg1, double _arg2,
| double _arg3, double _arg4)
| SetOriginCX(self, _arg:(float, float, float, float)) -> None
| C++: virtual void SetOriginCX(const double _arg[4])
|
| Imaginary and real value for C (constant in equation) and X
| (initial value).
|
| SetProjectionAxes(...)
| SetProjectionAxes(self, x:int, y:int, z:int) -> None
| C++: void SetProjectionAxes(int x, int y, int z)
| SetProjectionAxes(self, a:[int, int, int]) -> None
| C++: void SetProjectionAxes(int a[3])
|
| Set the projection from the 4D space (4 parameters / 2 imaginary
| numbers) to the axes of the 3D Volume. 0=C_Real, 1=C_Imaginary,
| 2=X_Real, 4=X_Imaginary
|
| SetSampleCX(...)
| SetSampleCX(self, _arg1:float, _arg2:float, _arg3:float,
| _arg4:float) -> None
| C++: virtual void SetSampleCX(double _arg1, double _arg2,
| double _arg3, double _arg4)
| SetSampleCX(self, _arg:(float, float, float, float)) -> None
| C++: virtual void SetSampleCX(const double _arg[4])
|
| Imaginary and real value for C (constant in equation) and X
| (initial value).
|
| SetSizeCX(...)
| SetSizeCX(self, cReal:float, cImag:float, xReal:float,
| xImag:float) -> None
| C++: void SetSizeCX(double cReal, double cImag, double xReal,
| double xImag)
|
| Just a different way of setting the sample. This sets the size of
| the 4D volume. SampleCX is computed from size and extent. Size is
| ignored when a dimension i 0 (collapsed).
|
| SetSubsampleRate(...)
| SetSubsampleRate(self, _arg:int) -> None
| C++: virtual void SetSubsampleRate(int _arg)
|
| Set/Get a subsample rate.
|
| SetWholeExtent(...)
| SetWholeExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void SetWholeExtent(int extent[6])
| SetWholeExtent(self, minX:int, maxX:int, minY:int, maxY:int,
| minZ:int, maxZ:int) -> None
| C++: void SetWholeExtent(int minX, int maxX, int minY, int maxY,
| int minZ, int maxZ)
|
| Set/Get the extent of the whole output Volume.
|
| Zoom(...)
| Zoom(self, factor:float) -> None
| C++: void Zoom(double factor)
|
| Convenience for Viewer. Pan 3D volume relative to spacing. Zoom
| constant factor.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkImagingSources.vtkImageMandelbrotSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkImagingSources.vtkImageMandelbrotSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkImagingSources.vtkImageMandelbrotSource:
|
| __this__
| Pointer to the C++ object.
|
| constant_size
| read-write, calls GetConstantSize/SetConstantSize
|
| maximum_number_of_iterations
| read-write, calls GetMaximumNumberOfIterations/SetMaximumNumberOfIterations
|
| origin_cx
| read-write, calls GetOriginCX/SetOriginCX
|
| projection_axes
| read-write, calls GetProjectionAxes/SetProjectionAxes
|
| sample_cx
| read-write, calls GetSampleCX/SetSampleCX
|
| size_cx
| read-write, calls GetSizeCX/SetSizeCX
|
| subsample_rate
| read-write, calls GetSubsampleRate/SetSubsampleRate
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkImagingSources.vtkImageMandelbrotSource:
|
| __vtkname__ = 'vtkImageMandelbrotSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: virtual void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: virtual void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| GetImageDataInput(...)
| GetImageDataInput(self, port:int) -> vtkImageData
| C++: vtkImageData *GetImageDataInput(int port)
|
| GetInput(...)
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
|
| Get a data object for one of the input port connections. The use
| of this method is strongly discouraged, but some filters that
| were written a long time ago still use this method.
|
| GetOutput(...)
| GetOutput(self) -> vtkImageData
| C++: vtkImageData *GetOutput()
| GetOutput(self, __a:int) -> vtkImageData
| C++: vtkImageData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.ImageNoiseSource
Python Library Documentation: class ImageNoiseSource in module pyvista.core.utilities.image_sources
class ImageNoiseSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageNoiseSource)
| ImageNoiseSource(*args, **kwargs) -> '_T'
|
| Create an image filled with uniform noise.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| whole_extent : sequence[int]
| The extent of the whole output image.
|
| minimum : float
| The minimum value for the generated noise.
|
| maximum : float
| The maximum value for the generated noise.
|
| seed : int, optional
| Seed the random number generator with a value.
|
| Examples
| --------
| Create an image of noise.
|
| >>> import pyvista as pv
| >>> source = pv.ImageNoiseSource(
| ... whole_extent=(0, 200, 0, 200, 0, 0),
| ... minimum=0,
| ... maximum=255,
| ... seed=0,
| ... )
| >>> source.output.plot(cpos='xy')
|
| Method resolution order:
| ImageNoiseSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkImagingSources.vtkImageNoiseSource
| vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, whole_extent=(0, 255, 0, 255, 0, 0), minimum=0.0, maximum=1.0, seed=None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| seed(self, value: 'int') -> 'None'
| Seed the random number generator with a value.
|
| Parameters
| ----------
| value : int
| The seed value for the random number generator to use.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output image as a ImageData.
|
| Returns
| -------
| pyvista.ImageData
| The output image.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| maximum
| Get the maximum value for the generated noise.
|
| Returns
| -------
| float
| The maximum value for the generated noise.
|
| minimum
| Get the minimum value for the generated noise.
|
| Returns
| -------
| float
| The minimum value for the generated noise.
|
| whole_extent
| Get extent of the whole output image.
|
| Returns
| -------
| sequence[int]
| The extent of the whole output image.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkImagingSources.vtkImageNoiseSource:
|
| GetMaximum(...)
| GetMaximum(self) -> float
| C++: virtual double GetMaximum()
|
| GetMinimum(...)
| GetMinimum(self) -> float
| C++: virtual double GetMinimum()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkImageNoiseSource
| C++: vtkImageNoiseSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkImageNoiseSource
| C++: static vtkImageNoiseSource *SafeDownCast(vtkObjectBase *o)
|
| SetMaximum(...)
| SetMaximum(self, _arg:float) -> None
| C++: virtual void SetMaximum(double _arg)
|
| SetMinimum(...)
| SetMinimum(self, _arg:float) -> None
| C++: virtual void SetMinimum(double _arg)
|
| Set/Get the minimum and maximum values for the generated noise.
|
| SetWholeExtent(...)
| SetWholeExtent(self, xMinx:int, xMax:int, yMin:int, yMax:int,
| zMin:int, zMax:int) -> None
| C++: void SetWholeExtent(int xMinx, int xMax, int yMin, int yMax,
| int zMin, int zMax)
| SetWholeExtent(self, ext:(int, int, int, int, int, int)) -> None
| C++: void SetWholeExtent(const int ext[6])
|
| Set how large of an image to generate.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkImagingSources.vtkImageNoiseSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkImagingSources.vtkImageNoiseSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkImagingSources.vtkImageNoiseSource:
|
| __this__
| Pointer to the C++ object.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkImagingSources.vtkImageNoiseSource:
|
| __vtkname__ = 'vtkImageNoiseSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: virtual void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: virtual void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| GetImageDataInput(...)
| GetImageDataInput(self, port:int) -> vtkImageData
| C++: vtkImageData *GetImageDataInput(int port)
|
| GetInput(...)
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
|
| Get a data object for one of the input port connections. The use
| of this method is strongly discouraged, but some filters that
| were written a long time ago still use this method.
|
| GetOutput(...)
| GetOutput(self) -> vtkImageData
| C++: vtkImageData *GetOutput()
| GetOutput(self, __a:int) -> vtkImageData
| C++: vtkImageData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.ImageSinusoidSource
Python Library Documentation: class ImageSinusoidSource in module pyvista.core.utilities.image_sources
class ImageSinusoidSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageSinusoidSource)
| ImageSinusoidSource(*args, **kwargs) -> '_T'
|
| Create an image of a sinusoid.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| whole_extent : sequence[int]
| The extent of the whole output image.
|
| direction : tuple
| The direction vector which determines the sinusoidal orientation.
|
| period : float
| The period of the sinusoid in pixel.
|
| phase : tuple
| The phase of the sinusoid in pixel.
|
| amplitude : float
| The magnitude of the sinusoid.
|
| Examples
| --------
| Create an image of a sinusoid.
|
| >>> import pyvista as pv
| >>> source = pv.ImageSinusoidSource(
| ... whole_extent=(0, 200, 0, 200, 0, 0),
| ... period=20.0,
| ... phase=0.0,
| ... amplitude=255,
| ... direction=(1.0, 0.0, 0.0),
| ... )
| >>> source.output.plot(cpos='xy')
|
| Method resolution order:
| ImageSinusoidSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkImagingSources.vtkImageSinusoidSource
| vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, whole_extent=None, direction=None, period=None, phase=None, amplitude=None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output image as a ImageData.
|
| Returns
| -------
| pyvista.ImageData
| The output image.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| amplitude
| Get the magnitude of the sinusoid.
|
| Returns
| -------
| float
| The magnitude of the sinusoid.
|
| direction
| Get the direction of the sinusoid.
|
| Returns
| -------
| sequence[float]
| The direction of the sinusoid.
|
| period
| Get the period of the sinusoid.
|
| Returns
| -------
| float
| The period of the sinusoid in pixel.
|
| phase
| Get the phase of the sinusoid.
|
| Returns
| -------
| sequence[float]
| The phase of the sinusoid in pixel.
|
| whole_extent
| Get extent of the whole output image.
|
| Returns
| -------
| sequence[int]
| The extent of the whole output image.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkImagingSources.vtkImageSinusoidSource:
|
| GetAmplitude(...)
| GetAmplitude(self) -> float
| C++: virtual double GetAmplitude()
|
| GetDirection(...)
| GetDirection(self) -> (float, float, float)
| C++: virtual double *GetDirection()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetPeriod(...)
| GetPeriod(self) -> float
| C++: virtual double GetPeriod()
|
| GetPhase(...)
| GetPhase(self) -> float
| C++: virtual double GetPhase()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkImageSinusoidSource
| C++: vtkImageSinusoidSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkImageSinusoidSource
| C++: static vtkImageSinusoidSource *SafeDownCast(vtkObjectBase *o)
|
| SetAmplitude(...)
| SetAmplitude(self, _arg:float) -> None
| C++: virtual void SetAmplitude(double _arg)
|
| Set/Get the magnitude of the sinusoid.
|
| SetDirection(...)
| SetDirection(self, __a:float, __b:float, __c:float) -> None
| C++: void SetDirection(double, double, double)
| SetDirection(self, dir:[float, float, float]) -> None
| C++: void SetDirection(double dir[3])
|
| Set/Get the direction vector which determines the sinusoidal
| orientation. The magnitude is ignored.
|
| SetPeriod(...)
| SetPeriod(self, _arg:float) -> None
| C++: virtual void SetPeriod(double _arg)
|
| Set/Get the period of the sinusoid in pixels.
|
| SetPhase(...)
| SetPhase(self, _arg:float) -> None
| C++: virtual void SetPhase(double _arg)
|
| Set/Get the phase: 0->2Pi. 0 => Cosine, pi/2 => Sine.
|
| SetWholeExtent(...)
| SetWholeExtent(self, xMinx:int, xMax:int, yMin:int, yMax:int,
| zMin:int, zMax:int) -> None
| C++: void SetWholeExtent(int xMinx, int xMax, int yMin, int yMax,
| int zMin, int zMax)
|
| Set/Get the extent of the whole output image.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkImagingSources.vtkImageSinusoidSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkImagingSources.vtkImageSinusoidSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkImagingSources.vtkImageSinusoidSource:
|
| __this__
| Pointer to the C++ object.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkImagingSources.vtkImageSinusoidSource:
|
| __vtkname__ = 'vtkImageSinusoidSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: virtual void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: virtual void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| GetImageDataInput(...)
| GetImageDataInput(self, port:int) -> vtkImageData
| C++: vtkImageData *GetImageDataInput(int port)
|
| GetInput(...)
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
|
| Get a data object for one of the input port connections. The use
| of this method is strongly discouraged, but some filters that
| were written a long time ago still use this method.
|
| GetOutput(...)
| GetOutput(self) -> vtkImageData
| C++: vtkImageData *GetOutput()
| GetOutput(self, __a:int) -> vtkImageData
| C++: vtkImageData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.InteractionEventType
Python Library Documentation: _UnionGenericAlias in module typing
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
pyvista.InvalidMeshError
Python Library Documentation: class InvalidMeshError in module pyvista.core.errors class InvalidMeshError(builtins.ValueError) | InvalidMeshError(message='Invalid mesh.') -> 'None' | | Error for invalid mesh properties. | | .. versionadded:: 0.47 | | Parameters | ---------- | message : str | Error message. | | Method resolution order: | InvalidMeshError | builtins.ValueError | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, message='Invalid mesh.') -> 'None' | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Static methods inherited from builtins.ValueError: | | __new__(*args, **kwargs) class method of builtins.ValueError | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.InvalidMeshWarning
Python Library Documentation: class InvalidMeshWarning in module pyvista.core.errors class InvalidMeshWarning(builtins.Warning) | Warning for invalid mesh properties. | | .. versionadded:: 0.47 | | Method resolution order: | InvalidMeshWarning | builtins.Warning | builtins.Exception | builtins.BaseException | builtins.object | | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Methods inherited from builtins.Warning: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.Warning: | | __new__(*args, **kwargs) class method of builtins.Warning | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.JPEGReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.JPEGWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.JupyterBackendOptions
Python Library Documentation: _LiteralGenericAlias in module typing
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
pyvista.JupyterBackendRegistration
Python Library Documentation: class JupyterBackendRegistration in module pyvista.jupyter
class JupyterBackendRegistration(builtins.tuple)
| JupyterBackendRegistration(name: ForwardRef('str'), handler: ForwardRef('Callable[..., object]'), source: ForwardRef('str'))
|
| Describe one registered custom Jupyter backend.
|
| Returned by :func:`~pyvista.registered_jupyter_backends`.
|
| .. versionadded:: 0.48.0
|
| Attributes
| ----------
| name : str
| Backend name.
| handler : callable
| The backend handler callable.
| source : str
| Human-readable origin in the form ``'module.qualname'`` for
| explicit registrations or the entry-point ``value`` for
| plugin-discovered registrations.
|
| Method resolution order:
| JupyterBackendRegistration
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.JupyterBackendRegistration
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.JupyterBackendRegistration
| Return a nicely formatted representation string
|
| _asdict(self) from collections.JupyterBackendRegistration
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.JupyterBackendRegistration
| Return a new JupyterBackendRegistration object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.JupyterBackendRegistration
| Make a new JupyterBackendRegistration object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, name: ForwardRef('str'), handler: ForwardRef('Callable[..., object]'), source: ForwardRef('str')) from namedtuple_JupyterBackendRegistration.JupyterBackendRegistration
| Create new instance of JupyterBackendRegistration(name, handler, source)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| name
| Alias for field number 0
|
| handler
| Alias for field number 1
|
| source
| Alias for field number 2
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'handler': ForwardRef('Callable[..., object]'), 'na...
|
| __match_args__ = ('name', 'handler', 'source')
|
| __orig_bases__ = (<function NamedTuple>,)
|
| _field_defaults = {}
|
| _fields = ('name', 'handler', 'source')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
pyvista.KochanekSpline
Python Library Documentation: function KochanekSpline in module pyvista.core.utilities.parametric_objects
KochanekSpline(points: 'VectorLike[float] | MatrixLike[float]', tension: 'VectorLike[float] | None' = None, bias: 'VectorLike[float] | None' = None, continuity: 'VectorLike[float] | None' = None, n_points: 'int | None' = None) -> 'PolyData'
Create a Kochanek spline from points.
Parameters
----------
points : array_like[float]
Array of points to build a Kochanek spline out of. Array must
be 3D and directionally ordered.
tension : sequence[float], default: [0.0, 0.0, 0.0]
Changes the length of the tangent vector.
bias : sequence[float], default: [0.0, 0.0, 0.0]
Primarily changes the direction of the tangent vector.
continuity : sequence[float], default: [0.0, 0.0, 0.0]
Changes the sharpness in change between tangents.
n_points : int, optional
Number of points on the spline. Defaults to ``points.shape[0]``.
Returns
-------
pyvista.PolyData
Kochanek spline.
Examples
--------
Construct a Kochanek spline.
>>> import numpy as np
>>> import pyvista as pv
>>> theta = np.linspace(-4 * np.pi, 4 * np.pi, 100)
>>> z = np.linspace(-2, 2, 100)
>>> r = z**2 + 1
>>> x = r * np.sin(theta)
>>> y = r * np.cos(theta)
>>> points = np.column_stack((x, y, z))
>>> kochanek_spline = pv.KochanekSpline(points, n_points=6)
>>> kochanek_spline.plot(line_width=4, color='k')
See :ref:`create_kochanek_spline_example` for an additional example.
pyvista.Line
Python Library Documentation: function Line in module pyvista.core.utilities.geometric_objects
Line(pointa: 'VectorLike[float]' = (-0.5, 0.0, 0.0), pointb: 'VectorLike[float]' = (0.5, 0.0, 0.0), resolution: 'int' = 1) -> 'PolyData'
Create a line.
Parameters
----------
pointa : sequence[float], default: (-0.5, 0.0, 0.0)
Location in ``[x, y, z]``.
pointb : sequence[float], default: (0.5, 0.0, 0.0)
Location in ``[x, y, z]``.
resolution : int, default: 1
Number of pieces to divide line into.
Returns
-------
pyvista.PolyData
Line mesh.
Examples
--------
Create a line between ``(0, 0, 0)`` and ``(0, 0, 1)``.
>>> import pyvista as pv
>>> mesh = pv.Line((0, 0, 0), (0, 0, 1))
>>> mesh.plot(color='k', line_width=10)
pyvista.LineSource
Python Library Documentation: class LineSource in module pyvista.core.utilities.geometric_sources
class LineSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkLineSource)
| LineSource(*args, **kwargs) -> '_T'
|
| Create a line.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| pointa : sequence[float], default: (-0.5, 0.0, 0.0)
| Location in ``[x, y, z]``.
|
| pointb : sequence[float], default: (0.5, 0.0, 0.0)
| Location in ``[x, y, z]``.
|
| resolution : int, default: 1
| Number of pieces to divide line into.
|
| Method resolution order:
| LineSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkLineSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'LineSource', pointa: 'VectorLike[float]' = (-0.5, 0.0, 0.0), pointb: 'VectorLike[float]' = (0.5, 0.0, 0.0), resolution: 'int' = 1) -> 'None'
| Initialize source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Line mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| pointa
| Location in ``[x, y, z]``.
|
| Returns
| -------
| sequence[float]
| Location in ``[x, y, z]``.
|
| pointb
| Location in ``[x, y, z]``.
|
| Returns
| -------
| sequence[float]
| Location in ``[x, y, z]``.
|
| resolution
| Number of pieces to divide line into.
|
| Returns
| -------
| int
| Number of pieces to divide line into.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfRefinementRatios(...)
| GetNumberOfRefinementRatios(self) -> int
| C++: int GetNumberOfRefinementRatios()
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetPoint1(...)
| GetPoint1(self) -> (float, float, float)
| C++: virtual double *GetPoint1()
|
| GetPoint2(...)
| GetPoint2(self) -> (float, float, float)
| C++: virtual double *GetPoint2()
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: virtual vtkPoints *GetPoints()
|
| GetRefinementRatio(...)
| GetRefinementRatio(self, index:int) -> float
| C++: double GetRefinementRatio(int index)
|
| GetResolution(...)
| GetResolution(self) -> int
| C++: virtual int GetResolution()
|
| GetResolutionMaxValue(...)
| GetResolutionMaxValue(self) -> int
| C++: virtual int GetResolutionMaxValue()
|
| GetResolutionMinValue(...)
| GetResolutionMinValue(self) -> int
| C++: virtual int GetResolutionMinValue()
|
| GetUseRegularRefinement(...)
| GetUseRegularRefinement(self) -> bool
| C++: virtual bool GetUseRegularRefinement()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkLineSource
| C++: vtkLineSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkLineSource
| C++: static vtkLineSource *SafeDownCast(vtkObjectBase *o)
|
| SetNumberOfRefinementRatios(...)
| SetNumberOfRefinementRatios(self, __a:int) -> None
| C++: void SetNumberOfRefinementRatios(int)
|
| API for setting/getting refinement ratios for points added to the
| line segment. The ratio is in the range `[0.0, 1.0]` where 0.0 is
| the start of the line segment and 1.0 is the end. When generating
| broken lines i.e. using `SetPoints`, this specifies refinement
| points for each of the individual line segment. Note that `0.0`
| and `1.0` must be explicitly included to generate a point and the
| start and/or end of the line segment. This is used only when
| `UseRegularRefinement` is false.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetPoint1(...)
| SetPoint1(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetPoint1(double _arg1, double _arg2,
| double _arg3)
| SetPoint1(self, _arg:(float, float, float)) -> None
| C++: virtual void SetPoint1(const double _arg[3])
|
| Set position of first end point.
|
| SetPoint2(...)
| SetPoint2(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetPoint2(double _arg1, double _arg2,
| double _arg3)
| SetPoint2(self, _arg:(float, float, float)) -> None
| C++: virtual void SetPoint2(const double _arg[3])
|
| Set position of other end point.
|
| SetPoints(...)
| SetPoints(self, __a:vtkPoints) -> None
| C++: virtual void SetPoints(vtkPoints *)
|
| Set/Get the list of points defining a broken line
|
| SetRefinementRatio(...)
| SetRefinementRatio(self, index:int, value:float) -> None
| C++: void SetRefinementRatio(int index, double value)
|
| SetResolution(...)
| SetResolution(self, _arg:int) -> None
| C++: virtual void SetResolution(int _arg)
|
| Divide line into Resolution number of pieces. This is used when
| `UseRegularRefinement` is true.
|
| SetUseRegularRefinement(...)
| SetUseRegularRefinement(self, _arg:bool) -> None
| C++: virtual void SetUseRegularRefinement(bool _arg)
|
| Set/Get how the line segment is to be refined. One can choose to
| add points at regular intervals per segment (defined using
| `Resolution`) or explicit locations (defined using
| `SetRefinementRatio`). Default is true i.e `Resolution` will be
| used to determine placement of points within each line segment.
|
| UseRegularRefinementOff(...)
| UseRegularRefinementOff(self) -> None
| C++: virtual void UseRegularRefinementOff()
|
| UseRegularRefinementOn(...)
| UseRegularRefinementOn(self) -> None
| C++: virtual void UseRegularRefinementOn()
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkLineSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| __this__
| Pointer to the C++ object.
|
| number_of_refinement_ratios
| read-write, calls GetNumberOfRefinementRatios/SetNumberOfRefinementRatios
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| point1
| read-write, calls GetPoint1/SetPoint1
|
| point2
| read-write, calls GetPoint2/SetPoint2
|
| points
| read-write, calls GetPoints/SetPoints
|
| use_regular_refinement
| read-write, calls GetUseRegularRefinement/SetUseRegularRefinement
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| __vtkname__ = 'vtkLineSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.Literal
Python Library Documentation: _LiteralSpecialForm in module typing
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
pyvista.LocalFileRequiredError
Python Library Documentation: class LocalFileRequiredError in module pyvista.core.utilities.reader_registry
class LocalFileRequiredError(builtins.Exception)
| Raise from a registered reader to signal it needs a local file path.
|
| When :func:`pyvista.read` passes a remote URI to a custom reader and
| the reader raises this exception, PyVista will download the file to a
| temporary local path and retry the reader automatically.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista.core.utilities.reader_registry import LocalFileRequiredError
| >>> @pv.register_reader('.myformat') # doctest: +SKIP
| ... def my_reader(path, **kwargs):
| ... if '://' in path:
| ... raise LocalFileRequiredError
| ... ...
|
| Method resolution order:
| LocalFileRequiredError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
pyvista.MAX_N_COLOR_BARS
Python Library Documentation: int object
class int(object)
| int([x]) -> integer
| int(x, base=10) -> integer
|
| Convert a number or string to an integer, or return 0 if no arguments
| are given. If x is a number, return x.__int__(). For floating-point
| numbers, this truncates towards zero.
|
| If x is not a number or if base is given, then x must be a string,
| bytes, or bytearray instance representing an integer literal in the
| given base. The literal can be preceded by '+' or '-' and be surrounded
| by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.
| Base 0 means to interpret the base from the string as an integer literal.
| >>> int('0b100', base=0)
| 4
|
| Built-in subclasses:
| bool
|
| Methods defined here:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __and__(self, value, /)
| Return self&value.
|
| __bool__(self, /)
| True if self else False
|
| __ceil__(...)
| Ceiling of an Integral returns itself.
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __eq__(self, value, /)
| Return self==value.
|
| __float__(self, /)
| float(self)
|
| __floor__(...)
| Flooring an Integral returns itself.
|
| __floordiv__(self, value, /)
| Return self//value.
|
| __format__(self, format_spec, /)
| Convert to a string according to format_spec.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __index__(self, /)
| Return self converted to an integer, if self is suitable for use as an index into a list.
|
| __int__(self, /)
| int(self)
|
| __invert__(self, /)
| ~self
|
| __le__(self, value, /)
| Return self<=value.
|
| __lshift__(self, value, /)
| Return self<<value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __mod__(self, value, /)
| Return self%value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __neg__(self, /)
| -self
|
| __or__(self, value, /)
| Return self|value.
|
| __pos__(self, /)
| +self
|
| __pow__(self, value, mod=None, /)
| Return pow(self, value, mod).
|
| __radd__(self, value, /)
| Return value+self.
|
| __rand__(self, value, /)
| Return value&self.
|
| __rdivmod__(self, value, /)
| Return divmod(value, self).
|
| __repr__(self, /)
| Return repr(self).
|
| __rfloordiv__(self, value, /)
| Return value//self.
|
| __rlshift__(self, value, /)
| Return value<<self.
|
| __rmod__(self, value, /)
| Return value%self.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __ror__(self, value, /)
| Return value|self.
|
| __round__(...)
| Rounding an Integral returns itself.
|
| Rounding with an ndigits argument also returns an integer.
|
| __rpow__(self, value, mod=None, /)
| Return pow(value, self, mod).
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| __rsub__(self, value, /)
| Return value-self.
|
| __rtruediv__(self, value, /)
| Return value/self.
|
| __rxor__(self, value, /)
| Return value^self.
|
| __sizeof__(self, /)
| Returns size in memory, in bytes.
|
| __sub__(self, value, /)
| Return self-value.
|
| __truediv__(self, value, /)
| Return self/value.
|
| __trunc__(...)
| Truncating an Integral returns itself.
|
| __xor__(self, value, /)
| Return self^value.
|
| as_integer_ratio(self, /)
| Return a pair of integers, whose ratio is equal to the original int.
|
| The ratio is in lowest terms and has a positive denominator.
|
| >>> (10).as_integer_ratio()
| (10, 1)
| >>> (-10).as_integer_ratio()
| (-10, 1)
| >>> (0).as_integer_ratio()
| (0, 1)
|
| bit_count(self, /)
| Number of ones in the binary representation of the absolute value of self.
|
| Also known as the population count.
|
| >>> bin(13)
| '0b1101'
| >>> (13).bit_count()
| 3
|
| bit_length(self, /)
| Number of bits necessary to represent self in binary.
|
| >>> bin(37)
| '0b100101'
| >>> (37).bit_length()
| 6
|
| conjugate(...)
| Returns self, the complex conjugate of any int.
|
| is_integer(self, /)
| Returns True. Exists for duck type compatibility with float.is_integer.
|
| to_bytes(self, /, length=1, byteorder='big', *, signed=False)
| Return an array of bytes representing an integer.
|
| length
| Length of bytes object to use. An OverflowError is raised if the
| integer is not representable with the given number of bytes. Default
| is length 1.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| `sys.byteorder' as the byte order value. Default is to use 'big'.
| signed
| Determines whether two's complement is used to represent the integer.
| If signed is False and a negative integer is given, an OverflowError
| is raised.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_bytes(bytes, byteorder='big', *, signed=False)
| Return the integer represented by the given array of bytes.
|
| bytes
| Holds the array of bytes to convert. The argument must either
| support the buffer protocol or be an iterable object producing bytes.
| Bytes and bytearray are examples of built-in objects that support the
| buffer protocol.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| `sys.byteorder' as the byte order value. Default is to use 'big'.
| signed
| Indicates whether two's complement is used to represent the integer.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| denominator
| the denominator of a rational number in lowest terms
|
| imag
| the imaginary part of a complex number
|
| numerator
| the numerator of a rational number in lowest terms
|
| real
| the real part of a complex number
pyvista.MFIXReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.MINCImageReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.MatrixLike
Python Library Documentation: _UnionGenericAlias in module typing
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
pyvista.MeshValidationFields
Python Library Documentation: _UnionGenericAlias in module typing
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
pyvista.MetaImageReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.MissingDataError
Python Library Documentation: class MissingDataError in module pyvista.core.errors class MissingDataError(builtins.ValueError) | MissingDataError(message='No data available.') -> 'None' | | Exception when data is missing, e.g. no active scalars can be set. | | Parameters | ---------- | message : str | Error message. | | Method resolution order: | MissingDataError | builtins.ValueError | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, message='No data available.') -> 'None' | Call the base class constructor with the custom message. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Static methods inherited from builtins.ValueError: | | __new__(*args, **kwargs) class method of builtins.ValueError | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.MultiBlock
Python Library Documentation: class MultiBlock in module pyvista.core.composite
class MultiBlock(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.filters.composite.CompositeFilters, pyvista.core.dataobject.DataObject, collections.abc.MutableSequence, vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet)
| MultiBlock(*args, **kwargs) -> '_T'
|
| A composite class to hold many data sets which can be iterated over.
|
| This wraps/extends the :vtk:`vtkMultiBlockDataSet` class
| so that we can easily plot these data sets and use the composite in a
| Pythonic manner.
|
| You can think of ``MultiBlock`` like a list as we
| can iterate over this data structure by index. It has some dictionary
| features as we can also access blocks by their string name.
|
| .. versionchanged:: 0.36.0
| ``MultiBlock`` adheres more closely to being list like, and inherits
| from :class:`collections.abc.MutableSequence`. Multiple nonconforming
| behaviors were removed or modified.
|
| Parameters
| ----------
| *args : dict, optional
| Data object dictionary.
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| **kwargs : dict, optional
| See :func:`pyvista.read` for additional options.
|
| Examples
| --------
| >>> import pyvista as pv
|
| Create an empty composite dataset.
|
| >>> blocks = pv.MultiBlock()
|
| Add a dataset to the collection.
|
| >>> sphere = pv.Sphere()
| >>> blocks.append(sphere)
|
| Add a named block.
|
| >>> blocks['cube'] = pv.Cube()
|
| Instantiate from a list of objects.
|
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.plot()
|
| Instantiate from a dictionary.
|
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.plot()
|
| Iterate over the collection.
|
| >>> for name in blocks.keys():
| ... block = blocks[name]
|
| >>> for block in blocks:
| ... # Do something with each dataset
| ... surf = block.extract_surface(algorithm=None)
|
| Method resolution order:
| MultiBlock
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.composite.CompositeFilters
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| collections.abc.MutableSequence
| collections.abc.Sequence
| collections.abc.Reversible
| collections.abc.Collection
| collections.abc.Sized
| collections.abc.Iterable
| collections.abc.Container
| vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObjectTree
| vtkmodules.vtkCommonDataModel.vtkCompositeDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __delitem__(self: 'MultiBlock', index: 'int | str | slice') -> 'None'
| Remove a block at the specified index.
|
| __eq__(self: 'MultiBlock', other: 'object') -> 'bool'
| Equality comparison.
|
| __getitem__(self: 'MultiBlock', index)
| Get a block by its index or name.
|
| If the name is non-unique then returns the first occurrence.
|
| __init__(self: 'MultiBlock', *args, validate: 'bool | _NestedMeshValidationFields' = False, **kwargs) -> 'None'
| Initialize multi block.
|
| __len__(self: 'MultiBlock') -> 'int'
| Return the number of blocks.
|
| __repr__(self: 'MultiBlock') -> 'str'
| Define an adequate representation.
|
| __setitem__(self: 'MultiBlock', index: 'int | str | slice', data) -> 'None'
| Set a block with a VTK data object.
|
| To set the name simultaneously, pass a string name as the 2nd index.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> multi = pv.MultiBlock()
| >>> multi.append(pv.PolyData())
| >>> multi[0] = pv.UnstructuredGrid()
| >>> multi.append(pv.PolyData(), 'poly')
| >>> multi.keys()
| ['Block-00', 'poly']
| >>> multi['bar'] = pv.PolyData()
| >>> multi.n_blocks
| 3
|
| __str__(self: 'MultiBlock') -> 'str'
| Return the str representation of the multi block.
|
| append(self: 'MultiBlock', dataset: '_TypeMultiBlockLeaf', name: 'str | None' = None) -> 'None'
| Add a data set to the next block index.
|
| Parameters
| ----------
| dataset : pyvista.DataSet or pyvista.MultiBlock
| Dataset to append to this multi-block.
|
| name : str, optional
| Block name to give to dataset. A default name is given
| depending on the block index as ``'Block-{i:02}'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.append(pv.Cone())
| >>> len(blocks)
| 3
| >>> blocks.append(examples.load_uniform(), 'uniform')
| >>> blocks.keys()
| ['cube', 'sphere', 'Block-02', 'uniform']
|
| as_polydata_blocks(self: 'MultiBlock', copy: 'bool' = False) -> 'MultiBlock'
| Convert all the datasets within this MultiBlock to :class:`~pyvista.PolyData`.
|
| Parameters
| ----------
| copy : bool, default: False
| Option to create a shallow copy of any datasets that are already a
| :class:`~pyvista.PolyData`. When ``False``, any datasets that are
| already PolyData will not be copied.
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock containing only :class:`pyvista.PolyData` datasets.
|
| See Also
| --------
| as_unstructured_grid_blocks
| Convert all blocks to :class:`~pyvista.UnstructuredGrid`.
| is_all_polydata
| Check if all blocks are :class:`~pyvista.PolyData`.
| :meth:`~pyvista.DataObjectFilters.extract_surface`
| Convert this :class:`~pyvista.MultiBlock` to :class:`~pyvista.PolyData`.
|
| Notes
| -----
| Null blocks are converted to empty :class:`pyvista.PolyData`
| objects. Downstream filters that operate on PolyData cannot accept
| MultiBlocks with null blocks.
|
| as_unstructured_grid_blocks(self: 'MultiBlock', copy: 'bool' = False) -> 'MultiBlock'
| Convert all the datasets within this MultiBlock to :class:`~pyvista.UnstructuredGrid`.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| copy : bool, default: False
| Option to create a shallow copy of any datasets that are already a
| :class:`~pyvista.UnstructuredGrid`. When ``False``, any datasets that are
| already UnstructuredGrid will not be copied.
|
| Returns
| -------
| MultiBlock
| MultiBlock containing only :class:`~pyvista.UnstructuredGrid` datasets.
|
| See Also
| --------
| as_polydata_blocks
|
| Notes
| -----
| Null blocks are converted to empty :class:`~pyvista.UnstructuredGrid`
| objects. Downstream filters that operate on UnstructuredGrid may not accept
| MultiBlocks with null blocks.
|
| clean(self: 'MultiBlock', empty: 'bool' = True) -> 'None'
| Remove any null blocks in place.
|
| Parameters
| ----------
| empty : bool, default: True
| Remove any meshes that are empty as well (have zero points).
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = {'cube': pv.Cube(), 'empty': pv.PolyData()}
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.clean(empty=True)
| >>> blocks.keys()
| ['cube']
|
| clear_all_cell_data(self: 'MultiBlock') -> 'None'
| Clear all cell data from all blocks.
|
| clear_all_data(self: 'MultiBlock') -> 'None'
| Clear all data from all blocks.
|
| clear_all_point_data(self: 'MultiBlock') -> 'None'
| Clear all point data from all blocks.
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the multiblock.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True``, make a full copy of the object.
|
| Returns
| -------
| pyvista.MultiBlock
| Deep or shallow copy of the ``MultiBlock``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> blocks = pv.MultiBlock(data)
| >>> new_blocks = blocks.copy()
| >>> len(new_blocks)
| 3
|
| copy_meta_from(self: 'MultiBlock', ido: 'MultiBlock', deep: 'bool') -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| deep_copy(self: 'MultiBlock', to_copy: '_vtk.vtkMultiBlockDataSet') -> 'None'
| Overwrite this MultiBlock with another MultiBlock as a deep copy.
|
| Parameters
| ----------
| to_copy : MultiBlock | :vtk:`vtkMultiBlockDataSet`
| MultiBlock to perform a deep copy from.
|
| extend(self: 'MultiBlock', datasets: 'Iterable[_TypeMultiBlockLeaf]') -> 'None'
| Extend MultiBlock with an Iterable.
|
| If another MultiBlock object is supplied, the key names will
| be preserved.
|
| Parameters
| ----------
| datasets : Iterable[pyvista.DataSet or pyvista.MultiBlock]
| Datasets to extend.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks_uniform = pv.MultiBlock({'uniform': examples.load_uniform()})
| >>> blocks.extend(blocks_uniform)
| >>> len(blocks)
| 3
| >>> blocks.keys()
| ['cube', 'sphere', 'uniform']
|
| flatten(self, *, order: "Literal['nested_first', 'nested_last'] | None" = None, name_mode: "Literal['preserve', 'prepend', 'reset']" = 'preserve', field_data_mode: "Literal['preserve', 'prepend']" = 'preserve', user_dict_mode: "Literal['preserve', 'prepend', 'flat', 'nested']" = 'preserve', separator: 'str' = '::', check_duplicate_keys: 'bool' = True, copy: 'bool' = True) -> 'MultiBlock'
| Flatten this :class:`MultiBlock`.
|
| Recursively iterate through all blocks and store them in a single
| :class:`MultiBlock` instance. All nested :class:`~pyvista.DataSet` and ``None``
| blocks are preserved, and any nested ``MultiBlock`` container blocks are removed.
| Field data from any nested ``MultiBlock`` containers is preserved, however, and
| is also flattened.
|
| The flattening operation is "safe" by default in the sense that duplicate keys
| for block names and field data are not allowed and no data will be overwritten.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| order : 'nested_last', 'nested_first', optional
| Order in which to flatten the contents.
|
| - ``'nested_first'``: Flatten nested ``MultiBlock`` blocks first.
| - ``'nested_last'``: Flatten nested ``MultiBlock`` blocks last.
|
| By default, the ``MultiBlock`` is flattened recursively as-is without
| changing the order.
|
| name_mode : 'preserve' | 'prepend' | 'reset', default: 'preserve'
| Mode for naming blocks in the flattened output.
|
| - ``'preserve'``: The names of all blocks are preserved.
| - ``'prepend'``: Preserve the block names and prepend the parent names.
| - ``'reset'``: Reset the block names to default values.
|
| field_data_mode : 'preserve' | 'prepend', default: 'preserve'
| Mode for naming the root field data keys when flattening nested field data.
|
| - ``'preserve'``: The array names of nested field data are preserved.
| - ``'prepend'``: Preserve the array names and prepend the parent names.
|
| user_dict_mode : 'preserve' | 'prepend' | 'flat' | 'nested', default: 'preserve'
| Mode for naming the flattened :attr:`~pyvista.DataObject.user_dict` keys when
| nested :class:`MultiBlock` blocks define a user-dict.
|
| - ``'preserve'``: Update the flattened user dict directly with the items of
| any nested user-dict.
| - ``'nested'``: Create nested keys in the flattened user-dict which match
| the nested hierarchy of any nested ``MultiBlock`` blocks.
| - ``'flat'``: Create a new key in the flattened user dict for each nested
| ``MultiBlock`` that has a user-dict.
| - ``'prepend'``: Similar to ``'flat'`` except the key names are prepended
| with the parent block names.
|
| .. note::
| If there is only a single level of nesting the ``'flat'``, ``'nested'``
| and ``'prepend'`` modes are all equivalent. They only differ when there
| is at least two levels of nesting.
|
| separator : str, default: '::'
| String separator to use when ``'prepend'`` mode is used. The separator
| is inserted between parent and child block name or field data array names.
|
| check_duplicate_keys : bool, default: True
| Flatten the MultiBlock data safely without overwriting any data or
| duplicating block names. If ``True``, an error is raised if any duplicate,
| non-unique field data keys or block names are identified. If ``False``,
| nested field data is flattened without checking for duplicate keys and data
| may be overwritten; the flattened MultiBlock may also have duplicate block
| names.
|
| copy : bool, default: True
| Return a deep copy of all nested blocks in the flattened ``MultiBlock``.
| If ``False``, shallow copies are returned.
|
| Returns
| -------
| MultiBlock
| Flattened ``MultiBlock``.
|
| See Also
| --------
| recursive_iterator
| move_nested_field_data_to_root
| pyvista.CompositeFilters.generic_filter
| clean
|
| Examples
| --------
| Create a nested :class:`MultiBlock` with three levels of nesting and
| three end nodes.
|
| >>> import pyvista as pv
| >>> nested = pv.MultiBlock(
| ... {
| ... 'nested1': pv.MultiBlock(
| ... {
| ... 'nested2': pv.MultiBlock({'poly': pv.PolyData()}),
| ... 'image': pv.ImageData(),
| ... }
| ... ),
| ... 'none': None,
| ... }
| ... )
|
| The root ``MultiBlock`` has two blocks.
|
| >>> nested.n_blocks
| 2
|
| >>> type(nested[0]), type(nested[1])
| (<class 'pyvista.core.composite.MultiBlock'>, <class 'NoneType'>)
|
| Flatten the ``MultiBlock``. The nested ``MultiBlock`` containers are removed
| and only their contents are returned (i.e. the three end nodes).
|
| >>> flat = nested.flatten()
| >>> flat.n_blocks
| 3
|
| >>> (
| ... type(flat[0]),
| ... type(flat[1]),
| ... type(flat[2]),
| ... ) # doctest: +NORMALIZE_WHITESPACE
| (<class 'pyvista.core.pointset.PolyData'>,
| <class 'pyvista.core.grid.ImageData'>,
| <class 'NoneType'>)
|
| By default, the block names are preserved.
|
| >>> flat.keys()
| ['poly', 'image', 'none']
|
| Prepend the names of parent blocks to the names instead.
|
| >>> flat = nested.flatten(name_mode='prepend')
| >>> flat.keys()
| ['nested1::nested2::poly', 'nested1::image', 'none']
|
| Reset the names to default values instead.
|
| >>> flat = nested.flatten(name_mode='reset')
| >>> flat.keys()
| ['Block-00', 'Block-01', 'Block-02']
|
| Flatten the ``MultiBlock`` with nested multi-blocks flattened last. Note the difference
| between this ordering of blocks and the default ordering returned earlier.
|
| >>> flat = nested.flatten(order='nested_last')
| >>> (
| ... type(flat[0]),
| ... type(flat[1]),
| ... type(flat[2]),
| ... ) # doctest: +NORMALIZE_WHITESPACE
| (<class 'NoneType'>,
| <class 'pyvista.core.grid.ImageData'>,
| <class 'pyvista.core.pointset.PolyData'>)
|
| get(self: 'MultiBlock', index: 'int | str', default: '_TypeMultiBlockLeaf' = None) -> '_TypeMultiBlockLeaf'
| Get a block by its index or name.
|
| If the name is non-unique then returns the first occurrence.
| Returns ``default`` if name isn't in the dataset.
|
| Parameters
| ----------
| index : int | str
| Index or name of the dataset within the multiblock.
|
| default : pyvista.DataSet or pyvista.MultiBlock, optional
| Default to return if index is not in the multiblock.
|
| Returns
| -------
| output : pyvista.DataSet | pyvista.MultiBlock | None
| Dataset from the given index if it exists.
|
| See Also
| --------
| get_block
| Get a block and raise an ``IndexError`` if index is not found.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> data = {'poly': pv.PolyData(), 'img': pv.ImageData()}
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.get('poly')
| PolyData ...
| >>> blocks.get('cone')
|
| get_block(self: 'MultiBlock', index: 'int | Sequence[int] | str') -> '_TypeMultiBlockLeaf'
| Get a block by its index or name.
|
| If the name is non-unique then returns the first occurrence. This
| method is similar to using ``[]`` for indexing except this method also
| supports indexing nested blocks.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| index : int | Sequence[int] | str
| Index or name of the dataset within the multiblock. Specify a sequence of
| indices to replace a nested block.
|
| Returns
| -------
| output : pyvista.DataSet | pyvista.MultiBlock | None
| Dataset from the given index if it exists.
|
| See Also
| --------
| get
| Get a block and return a default value instead of raising an ``IndexError``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> blocks = pv.MultiBlock([pv.PolyData(), pv.ImageData()])
| >>> nested = pv.MultiBlock([blocks])
|
| >>> nested.get_block(0)
| MultiBlock ...
| >>> nested.get_block((0, 1))
| ImageData ...
|
| get_block_name(self: 'MultiBlock', index: 'int') -> 'str'
| Return the string name of the block at the given index.
|
| Parameters
| ----------
| index : int
| Index of the block to get the name of.
|
| Returns
| -------
| str
| Name of the block at the given index.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.get_block_name(0)
| 'cube'
|
| get_data_range(self: 'MultiBlock', name: 'str | None', allow_missing: 'bool' = False, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min/max of an array given its name across all blocks.
|
| Parameters
| ----------
| name : str, optional
| The name of the array to get the range. If ``None``, the
| active scalars are used.
|
| allow_missing : bool, default: False
| Allow a block to be missing the named array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| .. versionadded:: 0.45
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| get_index_by_name(self: 'MultiBlock', name: 'str') -> 'int'
| Find the index number by block name.
|
| Parameters
| ----------
| name : str
| Name of the block.
|
| Returns
| -------
| int
| Index of the block.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.get_index_by_name('sphere')
| 1
|
| insert(self: 'MultiBlock', index: 'int', dataset: '_TypeMultiBlockLeaf', name: 'str | None' = None) -> 'None'
| Insert data before index.
|
| Parameters
| ----------
| index : int
| Index before which to insert data.
| dataset : pyvista.DataSet or pyvista.MultiBlock
| Data to insert.
| name : str, optional
| Name for key to give dataset. A default name is given
| depending on the block index as ``'Block-{i:02}'``.
|
| Examples
| --------
| Insert a new :class:`pyvista.PolyData` at the start of the multiblock.
|
| >>> import pyvista as pv
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.keys()
| ['cube', 'sphere']
| >>> blocks.insert(0, pv.Plane(), 'plane')
| >>> blocks.keys()
| ['plane', 'cube', 'sphere']
|
| keys(self: 'MultiBlock') -> 'list[str]'
| Get all the block names in the dataset.
|
| Returns
| -------
| list
| List of block names.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.keys()
| ['cube', 'sphere']
|
| move_nested_field_data_to_root(self, *, copy: 'bool | None' = None, field_data_mode: "Literal['preserve', 'prepend']" = 'preserve', user_dict_mode: "Literal['preserve', 'prepend', 'flat', 'nested']" = 'preserve', separator: 'str' = '::', check_duplicate_keys: 'bool' = True) -> 'None'
| Move or copy field data from all nested :class:`MultiBlock` blocks.
|
| Any nested :class:`MultiBlock` blocks will have its :attr:`~pyvista.DataObject.field_data`
| contents moved to the root block, (i.e. `this` ``MultiBock``). By default, this
| data will be cleared from the nested block(s) but a copy may be made instead.
|
| If any nested :class:`MultiBlock` blocks define a :attr:`~pyvista.DataObject.user_dict`,
| the root user-dict is also updated to include the nested block's user-dict
| data.
|
| All field data and user-dict keys are directly updated from the nested blocks
| by default. Optionally, different modes are provided to control the key names
| and/or how the data is moved. The move is done safely such that no key values
| will be overwritten and no data is lost. If any nested keys are duplicates
| of the root keys, an error is raised.
|
| .. note::
| This operation only applies to nested :class:`MultiBlock` blocks. Field data
| associated with :class:`~pyvista.DataSet` blocks is `not` affected.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| copy : bool, optional
| Set this value to copy the data. If ``True``, deep-copy the data from nested
| ``MultiBlock`` blocks to the root block. Both the root and nested blocks
| will share the same keys and refer to separate copies of the data. If
| ``False``, both the root and nested blocks will share the same keys but
| refer to the same data. By default, no copy is made; the nested field data
| is moved to the root block and cleared from the nested ``MultiBlock`` blocks.
|
| .. note::
|
| This option does not apply to any nested :attr:`~pyvista.DataObject.user_dict`
| data. User-dict data is always deep-copied.
|
| field_data_mode : 'preserve' | 'prepend', default: 'preserve'
| Mode for naming the root field data keys when moving nested field data.
|
| - ``'preserve'``: The array names of nested field data are preserved.
| - ``'prepend'``: Preserve the array names and prepend the parent names.
|
| user_dict_mode : 'preserve' | 'prepend' | 'flat' | 'nested', default: 'preserve'
| Mode for naming the root :attr:`~pyvista.DataObject.user_dict` keys when
| nested :class:`MultiBlock` blocks define a user-dict.
|
| - ``'preserve'``: Update the root user dict directly with the items of any
| nested user-dict.
| - ``'nested'``: Create nested keys in the root user-dict which match the
| nested hierarchy of any nested ``MultiBlock`` blocks.
| - ``'flat'``: Create a new key in the root user dict for each nested
| ``MultiBlock`` that has a user-dict.
| - ``'prepend'``: Similar to ``'flat'`` except the key names are prepended
| with the parent block names.
|
| .. note::
| If there is only a single level of nesting the ``'flat'``, ``'nested'``
| and ``'prepend'`` modes are all equivalent. They only differ when there
| is at least two levels of nesting.
|
| separator : str, default: '::'
| String separator to use when ``'prepend'`` mode is enabled for either field
| data or for the user-dict. The separator is inserted between parent and child
| block names.
|
| check_duplicate_keys : bool, default: True
| Update the root data safely without overwriting existing data. If ``True``,
| an error is raised if any nested keys match the root block's keys. If
| ``False``, nested data is moved without checking if a key already exists,
| and data may be overwritten.
|
| Raises
| ------
| ValueError
| If any field data keys in nested :class:`MultiBlock` blocks are duplicated
| in the root block and ``check_duplicate_keys`` is ``True``.
|
| See Also
| --------
| flatten
|
| Examples
| --------
| Create a :class:`MultiBlock` with field data.
|
| >>> import pyvista as pv
| >>> multi = pv.MultiBlock()
| >>> multi.field_data['data'] = [1, 2, 3]
|
| Nest the dataset inside another ``MultiBlock``.
|
| >>> root = pv.MultiBlock([multi])
|
| Show that the root block does not have any field data.
|
| >>> root.field_data.keys()
| []
|
| Move the nested field data to the root.
|
| >>> root.move_nested_field_data_to_root()
|
| The field data is now at the root.
|
| >>> root.field_data.keys()
| ['data']
|
| And no longer exists in the nested ``MultiBlock``.
|
| >>> multi.field_data.keys()
| []
|
| Add more field data to the nested block.
|
| >>> multi.field_data['more_data'] = [4, 5, 6]
|
| Move it to the root again, but this time prepend the name of the block the data
| came from.
|
| >>> root.move_nested_field_data_to_root(field_data_mode='prepend')
| >>> root.field_data.keys()
| ['data', 'Block-00::more_data']
|
| The :attr:`~pyvista.DataObject.user_dict` is also field data which is moved to
| the root block's user-dict.
|
| Add sample data to the nested block and move it to the root.
|
| >>> data = dict(foo='bar')
| >>> multi.user_dict = data
| >>> root.move_nested_field_data_to_root()
|
| Check the root's user-dict. By default, the key names are preserved and the root
| dict is updated with the nested dict.
|
| >>> root.user_dict
| {"foo": "bar"}
|
| Clear the field data and re-add data to the nested user-dict.
|
| >>> root.clear_field_data()
| >>> multi.user_dict = data
|
| Move the data again but use the ``'flat'`` mode. This time, a new key is added
| which matches the nested block's name.
|
| >>> root.move_nested_field_data_to_root(user_dict_mode='flat')
| >>> root.user_dict
| {"Block-00": {"foo": "bar"}}
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| pop(self: 'MultiBlock', index: 'int | str' = -1) -> '_TypeMultiBlockLeaf'
| Pop off a block at the specified index.
|
| Parameters
| ----------
| index : int or str, default: -1
| Index or name of the dataset within the multiblock. Defaults to
| last dataset.
|
| Returns
| -------
| output : pyvista.DataSet | pyvista.MultiBlock
| Dataset from the given index that was removed.
|
| Examples
| --------
| Pop the ``"cube"`` multiblock.
|
| >>> import pyvista as pv
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.keys()
| ['cube', 'sphere']
| >>> cube = blocks.pop('cube')
| >>> blocks.keys()
| ['sphere']
|
| recursive_iterator(self: 'MultiBlock', contents: "Literal['ids', 'names', 'blocks', 'items', 'all']" = 'blocks', order: "Literal['nested_first', 'nested_last'] | None" = None, *, node_type: "Literal['parent', 'child']" = 'child', skip_none: 'bool' = False, skip_empty: 'bool' = False, nested_ids: 'bool | None' = None, prepend_names: 'bool' = False, separator: 'str' = '::') -> 'Iterator[int | tuple[int, ...] | str | _TypeMultiBlockLeaf] | Iterator[tuple[str, _TypeMultiBlockLeaf]] | Iterator[tuple[int | tuple[int, ...], str, _TypeMultiBlockLeaf]]'
| Iterate over all nested blocks recursively.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| contents : 'ids' | 'names' | 'blocks' | 'items', default: 'blocks'
| Values to include in the iterator.
|
| - ``'ids'``: Return an iterator with nested block indices.
| - ``'names'``: Return an iterator with nested block names (i.e. :meth:`keys`).
| - ``'blocks'``: Return an iterator with nested blocks.
| - ``'items'``: Return an iterator with nested ``(name, block)`` pairs.
| - ``'all'``: Return an iterator with nested ``(index, name, block)`` triplets.
|
| .. note::
|
| Use the ``nested_ids`` and ``prepend_names`` options to modify how
| the block ids and names are represented, respectively.
|
| order : 'nested_first', 'nested_last', optional
| Order in which to iterate through nested blocks.
|
| - ``'nested_first'``: Iterate through nested ``MultiBlock`` blocks first.
| - ``'nested_last'``: Iterate through nested ``MultiBlock`` blocks last.
|
| By default, the ``MultiBlock`` is iterated recursively as-is without
| changing the order. This option only applies when ``node_type`` is ``'child'``.
|
| node_type : 'parent' | 'child', default: 'child'
| Type of node blocks to generate ``contents`` from. If ``'parent'``, the
| contents are generated from :class:`MultiBlock` nodes. If ``'child'``, the
| contents are generated from :class:`~pyvista.DataSet` and ``None`` nodes.
|
| skip_none : bool, default: False
| If ``True``, do not include ``None`` blocks in the iterator. This option
| only applies when ``node_type`` is ``'child'``.
|
| skip_empty : bool, default: False
| If ``True``, do not include empty meshes in the iterator. If ``node_type``
| is ``'parent'``, any :class:`MultiBlock` block with length ``0`` is skipped.
| If ``node_type`` is ``'child'``, any :class:`~pyvista.DataSet` block with
| ``0`` points is skipped.
|
| nested_ids : bool, default: True
| Prepend parent block indices to the child block indices. If ``True``, a
| tuple of indices is returned for each block. If ``False``, a single integer
| index is returned for each block. This option only applies when ``contents``
| is ``'ids'`` or ``'all'``.
|
| prepend_names : bool, default: False
| Prepend any parent block names to the child block names. This option
| only applies when ``contents`` is ``'names'``, ``'items'``, or ``'all'``.
|
| separator : str, default: '::'
| String separator to use when ``prepend_names`` is enabled. The separator
| is inserted between parent and child block names.
|
| Returns
| -------
| Iterator
| Iterator of ids, names, blocks, or name-block pairs depending on ``contents``.
|
| See Also
| --------
| flatten
| Uses the iterator internally to flatten a :class:`MultiBlock`.
| pyvista.CompositeFilters.generic_filter
| Uses the iterator internally to apply filters to all blocks.
| clean
| Remove ``None`` and/or empty mesh blocks.
|
| Examples
| --------
| Load a :class:`MultiBlock` with nested datasets.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> multi = examples.download_exodus()
|
| The dataset has eight :class:`MultiBlock` blocks.
|
| >>> multi.n_blocks
| 8
|
| >>> all(isinstance(block, pv.MultiBlock) for block in multi)
| True
|
| Get the iterator and show the count of all recursively nested blocks.
|
| >>> iterator = multi.recursive_iterator()
| >>> iterator
| <generator object MultiBlock._recursive_iterator at ...>
|
| >>> len(list(iterator))
| 11
|
| Check if all blocks are :class:`~pyvista.DataSet` objects. Note that ``None``
| blocks are included by default, so this may not be ``True`` in all cases.
|
| >>> all(isinstance(item, pv.DataSet) for item in multi.recursive_iterator())
| True
|
| Use the iterator to apply a filter inplace to all recursively nested datasets.
|
| >>> _ = [
| ... dataset.connectivity(inplace=True)
| ... for dataset in multi.recursive_iterator()
| ... ]
|
| Iterate through nested block names.
|
| >>> iterator = multi.recursive_iterator('names')
| >>> next(iterator)
| 'Unnamed block ID: 1'
|
| Prepend parent block names.
|
| >>> iterator = multi.recursive_iterator('names', prepend_names=True)
| >>> next(iterator)
| 'Element Blocks::Unnamed block ID: 1'
|
| Iterate through name-block pairs. Prepend parent block names again using a
| custom separator.
|
| >>> iterator = multi.recursive_iterator(
| ... 'items', prepend_names=True, separator='->'
| ... )
| >>> next(iterator)
| ('Element Blocks->Unnamed block ID: 1', UnstructuredGrid (...)
| N Cells: 336
| N Points: 400
| X Bounds: 0.000e+00, 1.200e+01
| Y Bounds: 0.000e+00, 3.500e+00
| Z Bounds: 0.000e+00, 3.399e+00
| N Arrays: 6)
|
| Iterate through ids. The ids are returned as a tuple by default.
|
| >>> iterator = multi.recursive_iterator('ids')
| >>> next(iterator)
| (0, 0)
|
| Use :meth:`get_block` and get the next block indicated by the nested ids.
|
| >>> multi.get_block(next(iterator))
| UnstructuredGrid ...
|
| Use the iterator to :attr:`replace` all blocks with new blocks. Similar to a previous
| example, we use a filter but this time the operation is not performed in place.
|
| >>> iterator = multi.recursive_iterator('all', nested_ids=True)
| >>> for ids, _, block in iterator:
| ... multi.replace(ids, block.connectivity())
|
| Use ``node_type='parent'`` to get information about :class:`MultiBlock` nodes.
|
| >>> iterator = multi.recursive_iterator(node_type='parent')
|
| The iterator has ``8`` items. In this case this matches the number of blocks
| in the root block.
|
| >>> len(list(iterator))
| 8
|
| Use ``skip_empty`` to skip :class:`MultiBlock` nodes which have length ``0``
| and return their block ids.
|
| >>> iterator = multi.recursive_iterator(
| ... 'ids', node_type='parent', skip_empty=True
| ... )
| >>> ids = list(iterator)
|
| There are two non-empty blocks at index ``0`` and ``4``.
|
| >>> len(ids)
| 2
| >>> ids
| [(0,), (4,)]
|
| replace(self: 'MultiBlock', index: 'int | Sequence[int] | str', dataset: '_TypeMultiBlockLeaf') -> 'None'
| Replace dataset at index while preserving key name.
|
| Parameters
| ----------
| index : int | Sequence[int] | str
| Index or name of the block to replace. Specify a sequence of indices to replace
| a nested block.
|
| .. versionadded:: 0.45
|
| Allow indexing nested blocks.
|
| dataset : pyvista.DataSet or pyvista.MultiBlock
| Dataset for replacing the one at index.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.replace(1, pv.Sphere(center=(10, 10, 10)))
| >>> blocks.keys()
| ['cube', 'sphere']
| >>> np.allclose(blocks[1].center, [10.0, 10.0, 10.0])
| True
|
| Load a dataset with nested blocks.
|
| >>> multi = examples.download_cgns_multi()
|
| Get one of the blocks and extract its surface.
|
| >>> block = multi[0][3]
| >>> surface = block.extract_surface(algorithm=None)
|
| Replace the block.
|
| >>> multi.replace((0, 3), surface)
|
| This is similar to replacing the block directly with indexing but the block
| name is also preserved.
|
| >>> multi[0][3] = surface
|
| reverse(self: 'MultiBlock') -> 'None'
| Reverse MultiBlock in-place.
|
| Examples
| --------
| Reverse a multiblock.
|
| >>> import pyvista as pv
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.keys()
| ['cube', 'sphere']
| >>> blocks.reverse()
| >>> blocks.keys()
| ['sphere', 'cube']
|
| set_active_scalars(self: 'MultiBlock', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell', allow_missing: 'bool' = False) -> 'tuple[FieldAssociation, NumpyArray[float]]'
| Find the scalars by name and appropriately set it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str or None
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| allow_missing : bool, default: False
| Allow missing scalars in part of the composite dataset. If all
| blocks are missing the array, it will raise a ``KeyError``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the scalars activated.
|
| numpy.ndarray
| An array from the dataset matching ``name``.
|
| Notes
| -----
| The number of components of the data must match.
|
| set_block_name(self: 'MultiBlock', index: 'int | str', name: 'str | None') -> 'None'
| Set a block's string name at the specified index.
|
| Parameters
| ----------
| index : int | str
| Index or the dataset within the multiblock.
|
| .. versionadded:: 0.45
|
| Allow indexing by name.
|
| name : str, optional
| Name to assign to the block at ``index``. If ``None``, no name is
| assigned to the block.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.append(pv.Cone())
| >>> blocks.set_block_name(2, 'cone')
| >>> blocks.keys()
| ['cube', 'sphere', 'cone']
|
| shallow_copy(self: 'MultiBlock', to_copy: '_vtk.vtkMultiBlockDataSet', recursive: 'bool' = False) -> 'None'
| Shallow copy the given multiblock to this multiblock.
|
| Parameters
| ----------
| to_copy : MultiBlock | :vtk:`vtkMultiBlockDataSet`
| Data object to perform a shallow copy from.
|
| recursive : bool, default: False
| Also shallow-copy any nested :class:`~pyvista.MultiBlock` blocks. By
| default, only the root :class:`~pyvista.MultiBlock` is shallow-copied and
| any nested multi-blocks are not shallow-copied.
|
| wrap_nested(self: 'MultiBlock') -> 'None'
| Ensure that all nested data structures are wrapped as PyVista datasets.
|
| This is performed in place.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| block_types
| Return a set of all block type(s).
|
| .. versionadded:: 0.45
|
| See Also
| --------
| nested_block_types
|
| Examples
| --------
| Load a dataset with nested multi-blocks. Here we load
| :func:`~pyvista.examples.downloads.download_cgns_multi`.
|
| >>> from pyvista import examples
| >>> multi = examples.download_cgns_multi()
|
| The dataset has eight nested multi-block blocks, so the block types
| only contains :class:`MultiBlock`.
|
| >>> multi.block_types
| {<class 'pyvista.core.composite.MultiBlock'>}
|
| The nested blocks only contain a single mesh type so the nested block types
| only contains :class:`~pyvista.UnstructuredGrid`.
|
| >>> multi.nested_block_types
| {<class 'pyvista.core.pointset.StructuredGrid'>}
|
| bounds
| Find min/max for bounds across blocks.
|
| Returns
| -------
| tuple[float, float, float, float, float, float]
| Length 6 tuple of floats containing min/max along each axis.
|
| Examples
| --------
| Return the bounds across blocks.
|
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 2.5,
| z_min = -0.5,
| z_max = 0.5)
|
| is_all_polydata
| Return ``True`` when all the blocks are :class:`~pyvista.PolyData`.
|
| This method will recursively check if any internal blocks are also
| :class:`~pyvista.PolyData`.
|
| Returns
| -------
| bool
| Return ``True`` when all blocks are :class:`~pyvista.PolyData`.
|
| See Also
| --------
| as_polydata_blocks
| Convert all blocks to :class:`~pyvista.PolyData`.
| :meth:`~pyvista.DataObjectFilters.extract_surface`
| Convert this :class:`~pyvista.MultiBlock` to :class:`~pyvista.PolyData`.
|
| is_empty
| Return ``True`` if there are no blocks.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.MultiBlock()
| >>> mesh.is_empty
| True
|
| >>> mesh.append(pv.Sphere())
| >>> mesh.is_empty
| False
|
| is_heterogeneous
| Return ``True`` any two nested blocks have different type.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| is_homogeneous
| nested_block_types
| recursive_iterator
|
| Examples
| --------
| Load a dataset with nested multi-blocks. Here we load
| :func:`~pyvista.examples.downloads.download_mug`.
|
| >>> from pyvista import examples
| >>> multi = examples.download_mug()
|
| Show the :attr:`nested_block_types`.
|
| >>> multi.nested_block_types # doctest:+SKIP
| {<class 'pyvista.core.pointset.UnstructuredGrid'>, <class 'NoneType'>}
|
| Since there is more than one type, the dataset is heterogeneous.
|
| >>> multi.is_heterogeneous
| True
|
| is_homogeneous
| Return ``True`` if all nested blocks have the same type.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| is_heterogeneous
| nested_block_types
| recursive_iterator
|
| Examples
| --------
| Load a dataset with nested multi-blocks. Here we load
| :func:`~pyvista.examples.downloads.download_cgns_multi`.
|
| >>> from pyvista import examples
| >>> multi = examples.download_cgns_multi()
|
| Show the :attr:`nested_block_types`.
|
| >>> multi.nested_block_types
| {<class 'pyvista.core.pointset.StructuredGrid'>}
|
| Since there is only one type, the dataset is homogeneous.
|
| >>> multi.is_homogeneous
| True
|
| is_nested
| Return ``True`` if any blocks are a :class:`MultiBlock`.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| Create a simple :class:`MultiBlock`:
|
| >>> import pyvista as pv
| >>> multi = pv.MultiBlock([pv.Sphere()])
|
| It only contains a :class:`~pyvista.DataSet`, so it is not nested.
|
| >>> multi.is_nested
| False
|
| Nest it inside another MultiBlock.
|
| >>> nested = pv.MultiBlock([multi])
| >>> nested.is_nested
| True
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.length
| 4.3584
|
| nested_block_types
| Return a set of all nested block type(s).
|
| .. versionadded:: 0.45
|
| See Also
| --------
| block_types
| is_homogeneous
| is_heterogeneous
| recursive_iterator
|
| Examples
| --------
| Load a dataset with nested multi-blocks. Here we load
| :func:`~pyvista.examples.downloads.download_cgns_multi`.
|
| >>> from pyvista import examples
| >>> multi = examples.download_cgns_multi()
|
| The dataset has eight nested multi-block blocks, so the block types
| only contains :class:`MultiBlock`.
|
| >>> multi.block_types
| {<class 'pyvista.core.composite.MultiBlock'>}
|
| The nested blocks only contain a single mesh type so the nested block types
| only contains :class:`~pyvista.UnstructuredGrid`.
|
| >>> multi.nested_block_types
| {<class 'pyvista.core.pointset.StructuredGrid'>}
|
| volume
| Return the total volume of all meshes in this dataset.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.volume
| 1.7348
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.center # doctest:+SKIP
| array([1., 1., 0.])
|
| n_blocks
| Return the total number of blocks set.
|
| Returns
| -------
| int
| Total number of blocks set.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.n_blocks
| 3
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.composite.CompositeFilters:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| combine(self, merge_points: 'bool' = False, tolerance=0.0)
| Combine all blocks into a single unstructured grid.
|
| Parameters
| ----------
| merge_points : bool, default: False
| Merge coincidental points.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Combined blocks.
|
| Examples
| --------
| Combine blocks within a multiblock without merging points.
|
| >>> import pyvista as pv
| >>> block = pv.MultiBlock(
| ... [
| ... pv.Cube(clean=False),
| ... pv.Cube(center=(1, 0, 0), clean=False),
| ... ]
| ... )
| >>> merged = block.combine()
| >>> merged.n_points
| 48
|
| Combine blocks and merge points
|
| >>> merged = block.combine(merge_points=True)
| >>> merged.n_points
| 12
|
| extract_geometry(self)
| Extract the surface the geometry of all blocks.
|
| Place this filter at the end of a pipeline before a polydata
| consumer such as a polydata mapper to extract geometry from
| all blocks and append them to one polydata object.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the composite dataset.
|
| generic_filter(self: 'MultiBlock', function: 'str | Callable[..., _TypeMultiBlockLeaf]', /, *args, **kwargs) -> 'MultiBlock'
| Apply any filter to all nested blocks recursively.
|
| This filter applies a user-specified function or method to all blocks in
| this :class:`~pyvista.MultiBlock`.
|
| .. note::
|
| If an ``inplace`` keyword is used, this ``MultiBlock`` is modified
| in-place along with all blocks.
|
| .. note::
|
| By default, the specified ``function`` is not applied to any ``None``
| blocks. These are simply skipped and passed through to the output.
|
| For advanced use, it is possible to apply the filter to ``None`` blocks
| by using the undocumented keyword ``_skip_none=False``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| function : Callable | str
| Callable function or name of the method to apply to each block. The function
| should accept a :class:`~pyvista.DataSet` as input and return either a
| :class:`~pyvista.DataSet` or :class:`~pyvista.MultiBlock` as output.
|
| *args : Any, optional
| Arguments to use with the specified ``function``.
|
| **kwargs : Any, optional
| Keyword arguments to use with the specified ``function``.
|
| Returns
| -------
| MultiBlock
| Filtered dataset.
|
| Raises
| ------
| RuntimeError
| Raised if the filter cannot be applied to any block for any reason. This
| overrides ``TypeError``, ``ValueError``, ``AttributeError`` errors when
| filtering.
|
| See Also
| --------
| pyvista.MultiBlock.flatten
| pyvista.MultiBlock.recursive_iterator
| pyvista.MultiBlock.clean
|
| Examples
| --------
| Create a :class:`~pyvista.MultiBlock` with various mesh types.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> volume = examples.load_uniform()
| >>> poly = examples.load_ant()
| >>> unstructured = examples.load_tetbeam()
| >>> multi = pv.MultiBlock([volume, poly, unstructured])
|
| >>> [type(block) for block in multi] # doctest: +NORMALIZE_WHITESPACE
| [<class 'pyvista.core.grid.ImageData'>,
| <class 'pyvista.core.pointset.PolyData'>,
| <class 'pyvista.core.pointset.UnstructuredGrid'>]
|
| Use the generic filter to apply :meth:`~pyvista.DataSet.cast_to_unstructured_grid`
| to all blocks.
|
| >>> filtered = multi.generic_filter('cast_to_unstructured_grid')
|
| >>> [type(block) for block in filtered] # doctest: +NORMALIZE_WHITESPACE
| [<class 'pyvista.core.pointset.UnstructuredGrid'>,
| <class 'pyvista.core.pointset.UnstructuredGrid'>,
| <class 'pyvista.core.pointset.UnstructuredGrid'>]
|
| Use the :meth:`~pyvista.DataSetFilters.partition` filter on all blocks.
| Any arguments can be specified as though the filter is being used directly.
|
| >>> filtered = multi.generic_filter('partition', 4, as_composite=True)
|
| Any function can be used as long as it returns a :class:`~pyvista.DataSet` or
| :class:`~pyvista.MultiBlock`. For example, we can normalize each block
| independently to have bounds between ``-0.5`` and ``0.5``.
|
| >>> def normalize_bounds(dataset):
| ... # Center the dataset
| ... dataset = dataset.translate(-np.array(dataset.center))
| ... # Scale the dataset
| ... factor = 1 / np.array(dataset.bounds_size)
| ... return dataset.scale(factor)
|
| >>> filtered = multi.generic_filter(normalize_bounds)
| >>> filtered
| MultiBlock (...)
| N Blocks: 3
| X Bounds: -5.000e-01, 5.000e-01
| Y Bounds: -5.000e-01, 5.000e-01
| Z Bounds: -5.000e-01, 5.000e-01
|
| The generic filter will fail if the filter can only be applied to some blocks
| but not others. For example, it is not possible to use the
| :meth:`~pyvista.ImageDataFilters.resample` filter generically since the
| ``MultiBlock`` above is heterogeneous and contains some blocks which are not
| :class:`~pyvista.ImageData`.
|
| >>> multi.generic_filter('resample', 0.5) # doctest:+SKIP
| RuntimeError: The filter 'resample' could not be applied to the block at index 1 with
| name 'Block-01' and type PolyData.
|
| Use a custom function instead to apply the generic filter conditionally. Here we
| filter the image blocks but simply pass-through a copy of any other blocks.
|
| >>> def conditional_resample(dataset, *args, **kwargs):
| ... if isinstance(dataset, pv.ImageData):
| ... return dataset.resample(*args, **kwargs)
| ... return dataset.copy()
|
| >>> filtered = multi.generic_filter(conditional_resample, 0.5)
|
| outline(self: 'MultiBlock', generate_faces: 'bool' = False, nested: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the all blocks in this composite dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box.
|
| nested : bool, default: False
| If ``True``, these creates individual outlines for each nested dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the outline.
|
| outline_corners(self: 'MultiBlock', factor=0.2, nested: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the corners for the all blocks in this composite dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| nested : bool, default: False
| If ``True``, these creates individual outlines for each nested dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from collections.abc.MutableSequence:
|
| __iadd__(self, values)
|
| clear(self)
| S.clear() -> None -- remove all items from S
|
| remove(self, value)
| S.remove(value) -- remove first occurrence of value.
| Raise ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Methods inherited from collections.abc.Sequence:
|
| __contains__(self, value)
|
| __iter__(self)
|
| __reversed__(self)
|
| count(self, value)
| S.count(value) -> integer -- return number of occurrences of value
|
| index(self, value, start=0, stop=None)
| S.index(value, [start, [stop]]) -> integer -- return first index of value.
| Raises ValueError if the value is not present.
|
| Supporting start and stop arguments is optional, but
| recommended.
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.abc.Reversible:
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.abc.Iterable:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet:
|
| GetBlock(...)
| GetBlock(self, blockno:int) -> vtkDataObject
| C++: vtkDataObject *GetBlock(unsigned int blockno)
|
| Returns the block at the given index. It is recommended that one
| uses the iterators to iterate over composite datasets rather than
| using this API.
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkMultiBlockDataSet
| C++: static vtkMultiBlockDataSet *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkMultiBlockDataSet
| C++: static vtkMultiBlockDataSet *GetData(vtkInformationVector *v,
| int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return class name of data type (see vtkType.h for definitions).
|
| GetMetaData(...)
| GetMetaData(self, blockno:int) -> vtkInformation
| C++: vtkInformation *GetMetaData(unsigned int blockno)
| GetMetaData(self, iter:vtkCompositeDataIterator) -> vtkInformation
| C++: vtkInformation *GetMetaData(vtkCompositeDataIterator *iter)
| override;
|
| Returns the meta-data for the block. If none is already present,
| a new vtkInformation object will be allocated. Use HasMetaData to
| avoid allocating vtkInformation objects.
|
| GetNumberOfBlocks(...)
| GetNumberOfBlocks(self) -> int
| C++: unsigned int GetNumberOfBlocks()
|
| Returns the number of blocks.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| HasMetaData(...)
| HasMetaData(self, blockno:int) -> int
| C++: vtkTypeBool HasMetaData(unsigned int blockno)
| HasMetaData(self, iter:vtkCompositeDataIterator) -> int
| C++: vtkTypeBool HasMetaData(vtkCompositeDataIterator *iter)
| override;
|
| Returns true if meta-data is available for a given block.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkMultiBlockDataSet
| C++: vtkMultiBlockDataSet *NewInstance()
|
| RemoveBlock(...)
| RemoveBlock(self, blockno:int) -> None
| C++: void RemoveBlock(unsigned int blockno)
|
| Remove the given block from the dataset.
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkMultiBlockDataSet
| C++: static vtkMultiBlockDataSet *SafeDownCast(vtkObjectBase *o)
|
| SetBlock(...)
| SetBlock(self, blockno:int, block:vtkDataObject) -> None
| C++: void SetBlock(unsigned int blockno, vtkDataObject *block)
|
| Sets the data object as the given block. The total number of
| blocks will be resized to fit the requested block no.
|
| @remark while most vtkDataObject subclasses, including
| vtkMultiBlockDataSet as acceptable as a block,
| `vtkPartitionedDataSet`, `vtkPartitionedDataSetCollection`, and
| `vtkUniformGridAMR` are not valid.
|
| SetNumberOfBlocks(...)
| SetNumberOfBlocks(self, numBlocks:int) -> None
| C++: void SetNumberOfBlocks(unsigned int numBlocks)
|
| Set the number of blocks. This will cause allocation if the new
| number of blocks is greater than the current size. All new blocks
| are initialized to null.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet:
|
| __this__
| Pointer to the C++ object.
|
| data_object_type
| read-only, calls GetDataObjectType
|
| number_of_blocks
| read-write, calls GetNumberOfBlocks/SetNumberOfBlocks
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet:
|
| __vtkname__ = 'vtkMultiBlockDataSet'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObjectTree:
|
| CompositeShallowCopy(...)
| CompositeShallowCopy(self, src:vtkCompositeDataSet) -> None
| C++: void CompositeShallowCopy(vtkCompositeDataSet *src) override;
|
| CompositeShallow, Shallow and Deep copy.
|
| CopyStructure(...)
| CopyStructure(self, input:vtkCompositeDataSet) -> None
| C++: void CopyStructure(vtkCompositeDataSet *input) override;
|
| Copies the tree structure from the input. All pointers to
| non-composite data objects are initialized to nullptr. This also
| shallow copies the meta data associated with all the nodes.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated.
|
| GetChild(...)
| GetChild(self, index:int) -> vtkDataObject
| C++: vtkDataObject *GetChild(unsigned int index)
|
| Returns a child dataset at a given index.
|
| GetChildMetaData(...)
| GetChildMetaData(self, index:int) -> vtkInformation
| C++: vtkInformation *GetChildMetaData(unsigned int index)
|
| Returns the meta-data at a given index. If the index is valid,
| however, no information object is set, then a new one will
| created and returned. To avoid unnecessary creation, use
| HasMetaData().
|
| GetDataSet(...)
| GetDataSet(self, iter:vtkCompositeDataIterator) -> vtkDataObject
| C++: vtkDataObject *GetDataSet(vtkCompositeDataIterator *iter)
| override;
| GetDataSet(self, flatIndex:int) -> vtkDataObject
| C++: virtual vtkDataObject *GetDataSet(unsigned int flatIndex)
|
| Returns the dataset located at the position pointed by the
| iterator. The iterator does not need to be iterating over this
| dataset itself. It can be an iterator for composite dataset with
| similar structure (achieved by using CopyStructure).
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| Returns the total number of cells of all blocks. This will
| iterate over all blocks and call GetNumberOfPoints() so it might
| be expensive.
|
| GetNumberOfChildren(...)
| GetNumberOfChildren(self) -> int
| C++: unsigned int GetNumberOfChildren()
|
| Get the number of children.
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| Returns the total number of points of all blocks. This will
| iterate over all blocks and call GetNumberOfPoints() so it might
| be expansive.
|
| HasChildMetaData(...)
| HasChildMetaData(self, index:int) -> int
| C++: vtkTypeBool HasChildMetaData(unsigned int index)
|
| Returns if meta-data information is available for the given child
| index. Returns 1 is present, 0 otherwise.
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Restore data object to initial state,
|
| NewIterator(...)
| NewIterator(self) -> vtkCompositeDataIterator
| C++: vtkCompositeDataIterator *NewIterator() override;
|
| Return a new iterator (the iterator has to be deleted by user).
|
| * Use NewTreeIterator when you have a pointer to a
| vtkDataObjectTree
| * and NewIterator when you have a pointer to a
| vtkCompositeDataSet;
| * NewIterator is inherited and calls NewTreeIterator internally.
|
| NewTreeIterator(...)
| NewTreeIterator(self) -> vtkDataObjectTreeIterator
| C++: virtual vtkDataObjectTreeIterator *NewTreeIterator()
|
| Return a new iterator (the iterator has to be deleted by user).
|
| SetDataSet(...)
| SetDataSet(self, iter:vtkCompositeDataIterator,
| dataObj:vtkDataObject) -> None
| C++: void SetDataSet(vtkCompositeDataIterator *iter,
| vtkDataObject *dataObj) override;
|
| Sets the data set at the location pointed by the iterator. The
| iterator does not need to be iterating over this dataset itself.
| It can be any composite datasite with similar structure (achieved
| by using CopyStructure).
|
| SetDataSetFrom(...)
| SetDataSetFrom(self, iter:vtkDataObjectTreeIterator,
| dataObj:vtkDataObject) -> None
| C++: void SetDataSetFrom(vtkDataObjectTreeIterator *iter,
| vtkDataObject *dataObj)
|
| Sets the data at the location provided by a
| vtkDataObjectTreeIterator
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the data up to the array
| pointers only. The implementation is delegated to the differenent
| subclasses. If you want to copy the actual data, @see DeepCopy.
|
| This method shallow copy the field data and copy the internal
| structure.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObjectTree:
|
| number_of_cells
| read-only, calls GetNumberOfCells
|
| number_of_children
| read-only, calls GetNumberOfChildren
|
| number_of_points
| read-only, calls GetNumberOfPoints
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkCompositeDataSet:
|
| CURRENT_PROCESS_CAN_LOAD_BLOCK(...)
| CURRENT_PROCESS_CAN_LOAD_BLOCK() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CURRENT_PROCESS_CAN_LOAD_BLOCK(
| )
|
| Key used to indicate that the current process can load the data
| in the node. Used for parallel readers where the nodes are
| assigned to the processes by the reader to indicate further down
| the pipeline which nodes will be on which processes.
| ***THIS IS AN EXPERIMENTAL KEY SUBJECT TO CHANGE WITHOUT
| NOTICE***\ingroup InformationKeys
|
| GetBounds(...)
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return the geometric bounding box in the form (xmin,xmax,
| ymin,ymax, zmin,zmax). Note that if the composite dataset
| contains abstract types (i.e., non vtkDataSet types) such as
| tables these will be ignored by the method. In cases where no
| vtkDataSet is contained in the composite dataset then the
| returned bounds will be undefined. THIS METHOD IS THREAD SAFE IF
| FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT
| MODIFIED.
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| NAME(...)
| NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *NAME()
|
| Key used to put node name in the meta-data associated with a
| node.\ingroup InformationKeys
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: virtual void Crop(const int *updateExtent)
|
| This method crops the data object (if necessary) so that the
| extent matches the update extent.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: virtual vtkFieldData *GetAttributesAsFieldData(int type)
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: virtual int GetExtentType()
|
| The ExtentType will be left as VTK_PIECES_EXTENT for data objects
| such as vtkPolyData and vtkUnstructuredGrid. The ExtentType will
| be changed to VTK_3D_EXTENT for data objects with 3D structure
| such as vtkImageData (and its subclass vtkStructuredPoints),
| vtkRectilinearGrid, and vtkStructuredGrid. The default is the
| have an extent in pieces, with only one piece (no streaming
| possible).
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: virtual vtkUnsignedCharArray *GetGhostArray(int type)
|
| Returns the ghost arrays of the data object of the specified
| attribute type. The type may be: POINT - Defined in
| vtkDataSet subclasses CELL - Defined in vtkDataSet subclasses.
| The other attribute types, will return nullptr since ghosts
| arrays are not defined for now outside of point or cell.
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Data objects are composite objects and need to check each part
| for MTime. The information object also needs to be considered.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| extent_type
| read-only, calls GetExtentType
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| m_time
| read-only, calls GetMTime
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.MultiBlockPlot3DReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.MultipleLines
Python Library Documentation: function MultipleLines in module pyvista.core.utilities.geometric_objects
MultipleLines(points: 'MatrixLike[float] | None' = None) -> 'PolyData'
Create multiple lines.
Parameters
----------
points : array_like[float], default: [[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]]
List of points defining a broken line.
Returns
-------
pyvista.PolyData
Line mesh.
Examples
--------
Create a multiple lines between ``(0, 0, 0)``, ``(1, 1, 1)`` and ``(0, 0, 1)``.
>>> import pyvista as pv
>>> mesh = pv.MultipleLines(points=[[0, 0, 0], [1, 1, 1], [0, 0, 1]])
>>> pl = pv.Plotter()
>>> actor = pl.add_mesh(mesh, color='k', line_width=10)
>>> pl.camera.azimuth = 45
>>> pl.camera.zoom(0.8)
>>> pl.show()
See :ref:`create_multiple_lines_example` and :ref:`color_lines_example`
for more examples.
pyvista.MultipleLinesSource
Python Library Documentation: class MultipleLinesSource in module pyvista.core.utilities.geometric_sources
class MultipleLinesSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkLineSource)
| MultipleLinesSource(*args, **kwargs) -> '_T'
|
| Multiple lines source algorithm class.
|
| Parameters
| ----------
| points : array_like[float], default: [[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]]
| List of points defining a broken line.
|
| Method resolution order:
| MultipleLinesSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkLineSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'MultipleLinesSource', points: 'MatrixLike[float] | None' = None) -> 'None'
| Initialize the multiple lines source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Line mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| points
| Return the points defining a broken line.
|
| Returns
| -------
| np.ndarray
| Points defining a broken line.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfRefinementRatios(...)
| GetNumberOfRefinementRatios(self) -> int
| C++: int GetNumberOfRefinementRatios()
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetPoint1(...)
| GetPoint1(self) -> (float, float, float)
| C++: virtual double *GetPoint1()
|
| GetPoint2(...)
| GetPoint2(self) -> (float, float, float)
| C++: virtual double *GetPoint2()
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: virtual vtkPoints *GetPoints()
|
| GetRefinementRatio(...)
| GetRefinementRatio(self, index:int) -> float
| C++: double GetRefinementRatio(int index)
|
| GetResolution(...)
| GetResolution(self) -> int
| C++: virtual int GetResolution()
|
| GetResolutionMaxValue(...)
| GetResolutionMaxValue(self) -> int
| C++: virtual int GetResolutionMaxValue()
|
| GetResolutionMinValue(...)
| GetResolutionMinValue(self) -> int
| C++: virtual int GetResolutionMinValue()
|
| GetUseRegularRefinement(...)
| GetUseRegularRefinement(self) -> bool
| C++: virtual bool GetUseRegularRefinement()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkLineSource
| C++: vtkLineSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkLineSource
| C++: static vtkLineSource *SafeDownCast(vtkObjectBase *o)
|
| SetNumberOfRefinementRatios(...)
| SetNumberOfRefinementRatios(self, __a:int) -> None
| C++: void SetNumberOfRefinementRatios(int)
|
| API for setting/getting refinement ratios for points added to the
| line segment. The ratio is in the range `[0.0, 1.0]` where 0.0 is
| the start of the line segment and 1.0 is the end. When generating
| broken lines i.e. using `SetPoints`, this specifies refinement
| points for each of the individual line segment. Note that `0.0`
| and `1.0` must be explicitly included to generate a point and the
| start and/or end of the line segment. This is used only when
| `UseRegularRefinement` is false.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetPoint1(...)
| SetPoint1(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetPoint1(double _arg1, double _arg2,
| double _arg3)
| SetPoint1(self, _arg:(float, float, float)) -> None
| C++: virtual void SetPoint1(const double _arg[3])
|
| Set position of first end point.
|
| SetPoint2(...)
| SetPoint2(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetPoint2(double _arg1, double _arg2,
| double _arg3)
| SetPoint2(self, _arg:(float, float, float)) -> None
| C++: virtual void SetPoint2(const double _arg[3])
|
| Set position of other end point.
|
| SetPoints(...)
| SetPoints(self, __a:vtkPoints) -> None
| C++: virtual void SetPoints(vtkPoints *)
|
| Set/Get the list of points defining a broken line
|
| SetRefinementRatio(...)
| SetRefinementRatio(self, index:int, value:float) -> None
| C++: void SetRefinementRatio(int index, double value)
|
| SetResolution(...)
| SetResolution(self, _arg:int) -> None
| C++: virtual void SetResolution(int _arg)
|
| Divide line into Resolution number of pieces. This is used when
| `UseRegularRefinement` is true.
|
| SetUseRegularRefinement(...)
| SetUseRegularRefinement(self, _arg:bool) -> None
| C++: virtual void SetUseRegularRefinement(bool _arg)
|
| Set/Get how the line segment is to be refined. One can choose to
| add points at regular intervals per segment (defined using
| `Resolution`) or explicit locations (defined using
| `SetRefinementRatio`). Default is true i.e `Resolution` will be
| used to determine placement of points within each line segment.
|
| UseRegularRefinementOff(...)
| UseRegularRefinementOff(self) -> None
| C++: virtual void UseRegularRefinementOff()
|
| UseRegularRefinementOn(...)
| UseRegularRefinementOn(self) -> None
| C++: virtual void UseRegularRefinementOn()
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkLineSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| __this__
| Pointer to the C++ object.
|
| number_of_refinement_ratios
| read-write, calls GetNumberOfRefinementRatios/SetNumberOfRefinementRatios
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| point1
| read-write, calls GetPoint1/SetPoint1
|
| point2
| read-write, calls GetPoint2/SetPoint2
|
| resolution
| read-write, calls GetResolution/SetResolution
|
| use_regular_refinement
| read-write, calls GetUseRegularRefinement/SetUseRegularRefinement
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| __vtkname__ = 'vtkLineSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.NIFTIImageWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.NIFTIReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.NRRDReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.Nek5000Reader
Error rendering doc: 'NoneType' object is not iterable
pyvista.NotAllTrianglesError
Python Library Documentation: class NotAllTrianglesError in module pyvista.core.errors class NotAllTrianglesError(builtins.ValueError) | NotAllTrianglesError(message='Mesh must consist of only triangles') -> 'None' | | Exception when a mesh does not contain all triangles. | | Parameters | ---------- | message : str | Error message. | | Method resolution order: | NotAllTrianglesError | builtins.ValueError | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, message='Mesh must consist of only triangles') -> 'None' | Empty init. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Static methods inherited from builtins.ValueError: | | __new__(*args, **kwargs) class method of builtins.ValueError | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.Number
Python Library Documentation: _UnionGenericAlias in module typing
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
pyvista.NumberType
Python Library Documentation: TypeVar in module pyvista.core._typing_core._array_like object
NumberType = class TypeVar(builtins.object)
| Type variable.
|
| The preferred way to construct a type variable is via the dedicated
| syntax for generic functions, classes, and type aliases::
|
| class Sequence[T]: # T is a TypeVar
| ...
|
| This syntax can also be used to create bound and constrained type
| variables::
|
| # S is a TypeVar bound to str
| class StrSequence[S: str]:
| ...
|
| # A is a TypeVar constrained to str or bytes
| class StrOrBytesSequence[A: (str, bytes)]:
| ...
|
| However, if desired, reusable type variables can also be constructed
| manually, like so::
|
| T = TypeVar('T') # Can be anything
| S = TypeVar('S', bound=str) # Can be any subtype of str
| A = TypeVar('A', str, bytes) # Must be exactly str or bytes
|
| Type variables exist primarily for the benefit of static type
| checkers. They serve as the parameters for generic types as well
| as for generic function and type alias definitions.
|
| The variance of type variables is inferred by type checkers when they
| are created through the type parameter syntax and when
| ``infer_variance=True`` is passed. Manually created type variables may
| be explicitly marked covariant or contravariant by passing
| ``covariant=True`` or ``contravariant=True``. By default, manually
| created type variables are invariant. See PEP 484 and PEP 695 for more
| details.
|
| Methods defined here:
|
| __mro_entries__(...)
|
| __or__(self, value, /)
| Return self|value.
|
| __reduce__(self, /)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __ror__(self, value, /)
| Return value|self.
|
| __typing_subst__(self, /, arg)
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __bound__
|
| __constraints__
|
| __contravariant__
|
| __covariant__
|
| __infer_variance__
pyvista.NumpyArray
Python Library Documentation: GenericAlias in module numpy
class ndarray(builtins.object)
| ndarray(shape, dtype=float, buffer=None, offset=0,
| strides=None, order=None)
|
| An array object represents a multidimensional, homogeneous array
| of fixed-size items. An associated data-type object describes the
| format of each element in the array (its byte-order, how many bytes it
| occupies in memory, whether it is an integer, a floating point number,
| or something else, etc.)
|
| Arrays should be constructed using `array`, `zeros` or `empty` (refer
| to the See Also section below). The parameters given here refer to
| a low-level method (`ndarray(...)`) for instantiating an array.
|
| For more information, refer to the `numpy` module and examine the
| methods and attributes of an array.
|
| Parameters
| ----------
| (for the __new__ method; see Notes below)
|
| shape : tuple of ints
| Shape of created array.
| dtype : data-type, optional
| Any object that can be interpreted as a numpy data type.
| buffer : object exposing buffer interface, optional
| Used to fill the array with data.
| offset : int, optional
| Offset of array data in buffer.
| strides : tuple of ints, optional
| Strides of data in memory.
| order : {'C', 'F'}, optional
| Row-major (C-style) or column-major (Fortran-style) order.
|
| Attributes
| ----------
| T : ndarray
| Transpose of the array.
| data : buffer
| The array's elements, in memory.
| dtype : dtype object
| Describes the format of the elements in the array.
| flags : dict
| Dictionary containing information related to memory use, e.g.,
| 'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc.
| flat : numpy.flatiter object
| Flattened version of the array as an iterator. The iterator
| allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for
| assignment examples; TODO).
| imag : ndarray
| Imaginary part of the array.
| real : ndarray
| Real part of the array.
| size : int
| Number of elements in the array.
| itemsize : int
| The memory use of each array element in bytes.
| nbytes : int
| The total number of bytes required to store the array data,
| i.e., ``itemsize * size``.
| ndim : int
| The array's number of dimensions.
| shape : tuple of ints
| Shape of the array.
| strides : tuple of ints
| The step-size required to move from one element to the next in
| memory. For example, a contiguous ``(3, 4)`` array of type
| ``int16`` in C-order has strides ``(8, 2)``. This implies that
| to move from element to element in memory requires jumps of 2 bytes.
| To move from row-to-row, one needs to jump 8 bytes at a time
| (``2 * 4``).
| ctypes : ctypes object
| Class containing properties of the array needed for interaction
| with ctypes.
| base : ndarray
| If the array is a view into another array, that array is its `base`
| (unless that array is also a view). The `base` array is where the
| array data is actually stored.
|
| See Also
| --------
| array : Construct an array.
| zeros : Create an array, each element of which is zero.
| empty : Create an array, but leave its allocated memory unchanged (i.e.,
| it contains "garbage").
| dtype : Create a data-type.
| numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`
| w.r.t. its `dtype.type <numpy.dtype.type>`.
|
| Notes
| -----
| There are two modes of creating an array using ``__new__``:
|
| 1. If `buffer` is None, then only `shape`, `dtype`, and `order`
| are used.
| 2. If `buffer` is an object exposing the buffer interface, then
| all keywords are interpreted.
|
| No ``__init__`` method is needed because the array is fully initialized
| after the ``__new__`` method.
|
| Examples
| --------
| These examples illustrate the low-level `ndarray` constructor. Refer
| to the `See Also` section above for easier ways of constructing an
| ndarray.
|
| First mode, `buffer` is None:
|
| >>> import numpy as np
| >>> np.ndarray(shape=(2,2), dtype=float, order='F')
| array([[0.0e+000, 0.0e+000], # random
| [ nan, 2.5e-323]])
|
| Second mode:
|
| >>> np.ndarray((2,), buffer=np.array([1,2,3]),
| ... offset=np.int_().itemsize,
| ... dtype=int) # offset = 1*itemsize, i.e. skip first element
| array([2, 3])
|
| Methods defined here:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __and__(self, value, /)
| Return self&value.
|
| __array__(...)
| a.__array__([dtype], *, copy=None)
|
| For ``dtype`` parameter it returns a new reference to self if
| ``dtype`` is not given or it matches array's data type.
| A new array of provided data type is returned if ``dtype``
| is different from the current data type of the array.
| For ``copy`` parameter it returns a new reference to self if
| ``copy=False`` or ``copy=None`` and copying isn't enforced by ``dtype``
| parameter. The method returns a new array for ``copy=True``, regardless of
| ``dtype`` parameter.
|
| A more detailed explanation of the ``__array__`` interface
| can be found in :ref:`dunder_array.interface`.
|
| __array_finalize__(...)
| a.__array_finalize__(obj, /)
|
| Present so subclasses can call super. Does nothing.
|
| __array_function__(...)
|
| __array_namespace__(...)
|
| __array_ufunc__(...)
|
| __array_wrap__(...)
| a.__array_wrap__(array[, context], /)
|
| Returns a view of `array` with the same type as self.
|
| __bool__(self, /)
| True if self else False
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __complex__(...)
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __copy__(...)
| a.__copy__()
|
| Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
|
| Equivalent to ``a.copy(order='K')``.
|
| __deepcopy__(...)
| a.__deepcopy__(memo, /)
|
| Used if :func:`copy.deepcopy` is called on an array.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __dlpack__(...)
| a.__dlpack__(*, stream=None, max_version=None, dl_device=None, copy=None)
|
| DLPack Protocol: Part of the Array API.
|
| __dlpack_device__(...)
| a.__dlpack_device__()
|
| DLPack Protocol: Part of the Array API.
|
| __eq__(self, value, /)
| Return self==value.
|
| __float__(self, /)
| float(self)
|
| __floordiv__(self, value, /)
| Return self//value.
|
| __format__(...)
| Default object formatter.
|
| Return str(self) if format_spec is empty. Raise TypeError otherwise.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __iadd__(self, value, /)
| Return self+=value.
|
| __iand__(self, value, /)
| Return self&=value.
|
| __ifloordiv__(self, value, /)
| Return self//=value.
|
| __ilshift__(self, value, /)
| Return self<<=value.
|
| __imatmul__(self, value, /)
| Return self@=value.
|
| __imod__(self, value, /)
| Return self%=value.
|
| __imul__(self, value, /)
| Return self*=value.
|
| __index__(self, /)
| Return self converted to an integer, if self is suitable for use as an index into a list.
|
| __int__(self, /)
| int(self)
|
| __invert__(self, /)
| ~self
|
| __ior__(self, value, /)
| Return self|=value.
|
| __ipow__(self, value, /)
| Return self**=value.
|
| __irshift__(self, value, /)
| Return self>>=value.
|
| __isub__(self, value, /)
| Return self-=value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __itruediv__(self, value, /)
| Return self/=value.
|
| __ixor__(self, value, /)
| Return self^=value.
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lshift__(self, value, /)
| Return self<<value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __matmul__(self, value, /)
| Return self@value.
|
| __mod__(self, value, /)
| Return self%value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __neg__(self, /)
| -self
|
| __or__(self, value, /)
| Return self|value.
|
| __pos__(self, /)
| +self
|
| __pow__(self, value, mod=None, /)
| Return pow(self, value, mod).
|
| __radd__(self, value, /)
| Return value+self.
|
| __rand__(self, value, /)
| Return value&self.
|
| __rdivmod__(self, value, /)
| Return divmod(value, self).
|
| __reduce__(...)
| a.__reduce__()
|
| For pickling.
|
| __reduce_ex__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __rfloordiv__(self, value, /)
| Return value//self.
|
| __rlshift__(self, value, /)
| Return value<<self.
|
| __rmatmul__(self, value, /)
| Return value@self.
|
| __rmod__(self, value, /)
| Return value%self.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __ror__(self, value, /)
| Return value|self.
|
| __rpow__(self, value, mod=None, /)
| Return pow(value, self, mod).
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| __rsub__(self, value, /)
| Return value-self.
|
| __rtruediv__(self, value, /)
| Return value/self.
|
| __rxor__(self, value, /)
| Return value^self.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __setstate__(...)
| a.__setstate__(state, /)
|
| For unpickling.
|
| The `state` argument must be a sequence that contains the following
| elements:
|
| Parameters
| ----------
| version : int
| optional pickle version. If omitted defaults to 0.
| shape : tuple
| dtype : data-type
| isFortran : bool
| rawdata : string or list
| a binary string with the data (or a list if 'a' is an object array)
|
| __sizeof__(...)
| Size of object in memory, in bytes.
|
| __str__(self, /)
| Return str(self).
|
| __sub__(self, value, /)
| Return self-value.
|
| __truediv__(self, value, /)
| Return self/value.
|
| __xor__(self, value, /)
| Return self^value.
|
| all(...)
| a.all(axis=None, out=None, keepdims=False, *, where=True)
|
| Returns True if all elements evaluate to True.
|
| Refer to `numpy.all` for full documentation.
|
| See Also
| --------
| numpy.all : equivalent function
|
| any(...)
| a.any(axis=None, out=None, keepdims=False, *, where=True)
|
| Returns True if any of the elements of `a` evaluate to True.
|
| Refer to `numpy.any` for full documentation.
|
| See Also
| --------
| numpy.any : equivalent function
|
| argmax(...)
| a.argmax(axis=None, out=None, *, keepdims=False)
|
| Return indices of the maximum values along the given axis.
|
| Refer to `numpy.argmax` for full documentation.
|
| See Also
| --------
| numpy.argmax : equivalent function
|
| argmin(...)
| a.argmin(axis=None, out=None, *, keepdims=False)
|
| Return indices of the minimum values along the given axis.
|
| Refer to `numpy.argmin` for detailed documentation.
|
| See Also
| --------
| numpy.argmin : equivalent function
|
| argpartition(...)
| a.argpartition(kth, axis=-1, kind='introselect', order=None)
|
| Returns the indices that would partition this array.
|
| Refer to `numpy.argpartition` for full documentation.
|
| .. versionadded:: 1.8.0
|
| See Also
| --------
| numpy.argpartition : equivalent function
|
| argsort(...)
| a.argsort(axis=-1, kind=None, order=None)
|
| Returns the indices that would sort this array.
|
| Refer to `numpy.argsort` for full documentation.
|
| See Also
| --------
| numpy.argsort : equivalent function
|
| astype(...)
| a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
|
| Copy of the array, cast to a specified type.
|
| Parameters
| ----------
| dtype : str or dtype
| Typecode or data-type to which the array is cast.
| order : {'C', 'F', 'A', 'K'}, optional
| Controls the memory layout order of the result.
| 'C' means C order, 'F' means Fortran order, 'A'
| means 'F' order if all the arrays are Fortran contiguous,
| 'C' order otherwise, and 'K' means as close to the
| order the array elements appear in memory as possible.
| Default is 'K'.
| casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
| Controls what kind of data casting may occur. Defaults to 'unsafe'
| for backwards compatibility.
|
| * 'no' means the data types should not be cast at all.
| * 'equiv' means only byte-order changes are allowed.
| * 'safe' means only casts which can preserve values are allowed.
| * 'same_kind' means only safe casts or casts within a kind,
| like float64 to float32, are allowed.
| * 'unsafe' means any data conversions may be done.
| subok : bool, optional
| If True, then sub-classes will be passed-through (default), otherwise
| the returned array will be forced to be a base-class array.
| copy : bool, optional
| By default, astype always returns a newly allocated array. If this
| is set to false, and the `dtype`, `order`, and `subok`
| requirements are satisfied, the input array is returned instead
| of a copy.
|
| Returns
| -------
| arr_t : ndarray
| Unless `copy` is False and the other conditions for returning the input
| array are satisfied (see description for `copy` input parameter), `arr_t`
| is a new array of the same shape as the input array, with dtype, order
| given by `dtype`, `order`.
|
| Notes
| -----
| .. versionchanged:: 1.17.0
| Casting between a simple data type and a structured one is possible only
| for "unsafe" casting. Casting to multiple fields is allowed, but
| casting from multiple fields is not.
|
| .. versionchanged:: 1.9.0
| Casting from numeric to string types in 'safe' casting mode requires
| that the string dtype length is long enough to store the max
| integer/float value converted.
|
| Raises
| ------
| ComplexWarning
| When casting from complex to float or int. To avoid this,
| one should use ``a.real.astype(t)``.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.array([1, 2, 2.5])
| >>> x
| array([1. , 2. , 2.5])
|
| >>> x.astype(int)
| array([1, 2, 2])
|
| byteswap(...)
| a.byteswap(inplace=False)
|
| Swap the bytes of the array elements
|
| Toggle between low-endian and big-endian data representation by
| returning a byteswapped array, optionally swapped in-place.
| Arrays of byte-strings are not swapped. The real and imaginary
| parts of a complex number are swapped individually.
|
| Parameters
| ----------
| inplace : bool, optional
| If ``True``, swap bytes in-place, default is ``False``.
|
| Returns
| -------
| out : ndarray
| The byteswapped array. If `inplace` is ``True``, this is
| a view to self.
|
| Examples
| --------
| >>> import numpy as np
| >>> A = np.array([1, 256, 8755], dtype=np.int16)
| >>> list(map(hex, A))
| ['0x1', '0x100', '0x2233']
| >>> A.byteswap(inplace=True)
| array([ 256, 1, 13090], dtype=int16)
| >>> list(map(hex, A))
| ['0x100', '0x1', '0x3322']
|
| Arrays of byte-strings are not swapped
|
| >>> A = np.array([b'ceg', b'fac'])
| >>> A.byteswap()
| array([b'ceg', b'fac'], dtype='|S3')
|
| ``A.view(A.dtype.newbyteorder()).byteswap()`` produces an array with
| the same values but different representation in memory
|
| >>> A = np.array([1, 2, 3])
| >>> A.view(np.uint8)
| array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
| 0, 0], dtype=uint8)
| >>> A.view(A.dtype.newbyteorder()).byteswap(inplace=True)
| array([1, 2, 3])
| >>> A.view(np.uint8)
| array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
| 0, 3], dtype=uint8)
|
| choose(...)
| a.choose(choices, out=None, mode='raise')
|
| Use an index array to construct a new array from a set of choices.
|
| Refer to `numpy.choose` for full documentation.
|
| See Also
| --------
| numpy.choose : equivalent function
|
| clip(...)
| a.clip(min=None, max=None, out=None, **kwargs)
|
| Return an array whose values are limited to ``[min, max]``.
| One of max or min must be given.
|
| Refer to `numpy.clip` for full documentation.
|
| See Also
| --------
| numpy.clip : equivalent function
|
| compress(...)
| a.compress(condition, axis=None, out=None)
|
| Return selected slices of this array along given axis.
|
| Refer to `numpy.compress` for full documentation.
|
| See Also
| --------
| numpy.compress : equivalent function
|
| conj(...)
| a.conj()
|
| Complex-conjugate all elements.
|
| Refer to `numpy.conjugate` for full documentation.
|
| See Also
| --------
| numpy.conjugate : equivalent function
|
| conjugate(...)
| a.conjugate()
|
| Return the complex conjugate, element-wise.
|
| Refer to `numpy.conjugate` for full documentation.
|
| See Also
| --------
| numpy.conjugate : equivalent function
|
| copy(...)
| a.copy(order='C')
|
| Return a copy of the array.
|
| Parameters
| ----------
| order : {'C', 'F', 'A', 'K'}, optional
| Controls the memory layout of the copy. 'C' means C-order,
| 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
| 'C' otherwise. 'K' means match the layout of `a` as closely
| as possible. (Note that this function and :func:`numpy.copy` are very
| similar but have different default values for their order=
| arguments, and this function always passes sub-classes through.)
|
| See also
| --------
| numpy.copy : Similar function with different default behavior
| numpy.copyto
|
| Notes
| -----
| This function is the preferred method for creating an array copy. The
| function :func:`numpy.copy` is similar, but it defaults to using order 'K',
| and will not pass sub-classes through by default.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.array([[1,2,3],[4,5,6]], order='F')
|
| >>> y = x.copy()
|
| >>> x.fill(0)
|
| >>> x
| array([[0, 0, 0],
| [0, 0, 0]])
|
| >>> y
| array([[1, 2, 3],
| [4, 5, 6]])
|
| >>> y.flags['C_CONTIGUOUS']
| True
|
| For arrays containing Python objects (e.g. dtype=object),
| the copy is a shallow one. The new array will contain the
| same object which may lead to surprises if that object can
| be modified (is mutable):
|
| >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
| >>> b = a.copy()
| >>> b[2][0] = 10
| >>> a
| array([1, 'm', list([10, 3, 4])], dtype=object)
|
| To ensure all elements within an ``object`` array are copied,
| use `copy.deepcopy`:
|
| >>> import copy
| >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
| >>> c = copy.deepcopy(a)
| >>> c[2][0] = 10
| >>> c
| array([1, 'm', list([10, 3, 4])], dtype=object)
| >>> a
| array([1, 'm', list([2, 3, 4])], dtype=object)
|
| cumprod(...)
| a.cumprod(axis=None, dtype=None, out=None)
|
| Return the cumulative product of the elements along the given axis.
|
| Refer to `numpy.cumprod` for full documentation.
|
| See Also
| --------
| numpy.cumprod : equivalent function
|
| cumsum(...)
| a.cumsum(axis=None, dtype=None, out=None)
|
| Return the cumulative sum of the elements along the given axis.
|
| Refer to `numpy.cumsum` for full documentation.
|
| See Also
| --------
| numpy.cumsum : equivalent function
|
| diagonal(...)
| a.diagonal(offset=0, axis1=0, axis2=1)
|
| Return specified diagonals. In NumPy 1.9 the returned array is a
| read-only view instead of a copy as in previous NumPy versions. In
| a future version the read-only restriction will be removed.
|
| Refer to :func:`numpy.diagonal` for full documentation.
|
| See Also
| --------
| numpy.diagonal : equivalent function
|
| dot(...)
|
| dump(...)
| a.dump(file)
|
| Dump a pickle of the array to the specified file.
| The array can be read back with pickle.load or numpy.load.
|
| Parameters
| ----------
| file : str or Path
| A string naming the dump file.
|
| .. versionchanged:: 1.17.0
| `pathlib.Path` objects are now accepted.
|
| dumps(...)
| a.dumps()
|
| Returns the pickle of the array as a string.
| pickle.loads will convert the string back to an array.
|
| Parameters
| ----------
| None
|
| fill(...)
| a.fill(value)
|
| Fill the array with a scalar value.
|
| Parameters
| ----------
| value : scalar
| All elements of `a` will be assigned this value.
|
| Examples
| --------
| >>> import numpy as np
| >>> a = np.array([1, 2])
| >>> a.fill(0)
| >>> a
| array([0, 0])
| >>> a = np.empty(2)
| >>> a.fill(1)
| >>> a
| array([1., 1.])
|
| Fill expects a scalar value and always behaves the same as assigning
| to a single array element. The following is a rare example where this
| distinction is important:
|
| >>> a = np.array([None, None], dtype=object)
| >>> a[0] = np.array(3)
| >>> a
| array([array(3), None], dtype=object)
| >>> a.fill(np.array(3))
| >>> a
| array([array(3), array(3)], dtype=object)
|
| Where other forms of assignments will unpack the array being assigned:
|
| >>> a[...] = np.array(3)
| >>> a
| array([3, 3], dtype=object)
|
| flatten(...)
| a.flatten(order='C')
|
| Return a copy of the array collapsed into one dimension.
|
| Parameters
| ----------
| order : {'C', 'F', 'A', 'K'}, optional
| 'C' means to flatten in row-major (C-style) order.
| 'F' means to flatten in column-major (Fortran-
| style) order. 'A' means to flatten in column-major
| order if `a` is Fortran *contiguous* in memory,
| row-major order otherwise. 'K' means to flatten
| `a` in the order the elements occur in memory.
| The default is 'C'.
|
| Returns
| -------
| y : ndarray
| A copy of the input array, flattened to one dimension.
|
| See Also
| --------
| ravel : Return a flattened array.
| flat : A 1-D flat iterator over the array.
|
| Examples
| --------
| >>> import numpy as np
| >>> a = np.array([[1,2], [3,4]])
| >>> a.flatten()
| array([1, 2, 3, 4])
| >>> a.flatten('F')
| array([1, 3, 2, 4])
|
| getfield(...)
| a.getfield(dtype, offset=0)
|
| Returns a field of the given array as a certain type.
|
| A field is a view of the array data with a given data-type. The values in
| the view are determined by the given type and the offset into the current
| array in bytes. The offset needs to be such that the view dtype fits in the
| array dtype; for example an array of dtype complex128 has 16-byte elements.
| If taking a view with a 32-bit integer (4 bytes), the offset needs to be
| between 0 and 12 bytes.
|
| Parameters
| ----------
| dtype : str or dtype
| The data type of the view. The dtype size of the view can not be larger
| than that of the array itself.
| offset : int
| Number of bytes to skip before beginning the element view.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.diag([1.+1.j]*2)
| >>> x[1, 1] = 2 + 4.j
| >>> x
| array([[1.+1.j, 0.+0.j],
| [0.+0.j, 2.+4.j]])
| >>> x.getfield(np.float64)
| array([[1., 0.],
| [0., 2.]])
|
| By choosing an offset of 8 bytes we can select the complex part of the
| array for our view:
|
| >>> x.getfield(np.float64, offset=8)
| array([[1., 0.],
| [0., 4.]])
|
| item(...)
| a.item(*args)
|
| Copy an element of an array to a standard Python scalar and return it.
|
| Parameters
| ----------
| \*args : Arguments (variable number and type)
|
| * none: in this case, the method only works for arrays
| with one element (`a.size == 1`), which element is
| copied into a standard Python scalar object and returned.
|
| * int_type: this argument is interpreted as a flat index into
| the array, specifying which element to copy and return.
|
| * tuple of int_types: functions as does a single int_type argument,
| except that the argument is interpreted as an nd-index into the
| array.
|
| Returns
| -------
| z : Standard Python scalar object
| A copy of the specified element of the array as a suitable
| Python scalar
|
| Notes
| -----
| When the data type of `a` is longdouble or clongdouble, item() returns
| a scalar array object because there is no available Python scalar that
| would not lose information. Void arrays return a buffer object for item(),
| unless fields are defined, in which case a tuple is returned.
|
| `item` is very similar to a[args], except, instead of an array scalar,
| a standard Python scalar is returned. This can be useful for speeding up
| access to elements of the array and doing arithmetic on elements of the
| array using Python's optimized math.
|
| Examples
| --------
| >>> import numpy as np
| >>> np.random.seed(123)
| >>> x = np.random.randint(9, size=(3, 3))
| >>> x
| array([[2, 2, 6],
| [1, 3, 6],
| [1, 0, 1]])
| >>> x.item(3)
| 1
| >>> x.item(7)
| 0
| >>> x.item((0, 1))
| 2
| >>> x.item((2, 2))
| 1
|
| For an array with object dtype, elements are returned as-is.
|
| >>> a = np.array([np.int64(1)], dtype=object)
| >>> a.item() #return np.int64
| np.int64(1)
|
| max(...)
| a.max(axis=None, out=None, keepdims=False, initial=<no value>, where=True)
|
| Return the maximum along a given axis.
|
| Refer to `numpy.amax` for full documentation.
|
| See Also
| --------
| numpy.amax : equivalent function
|
| mean(...)
| a.mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True)
|
| Returns the average of the array elements along given axis.
|
| Refer to `numpy.mean` for full documentation.
|
| See Also
| --------
| numpy.mean : equivalent function
|
| min(...)
| a.min(axis=None, out=None, keepdims=False, initial=<no value>, where=True)
|
| Return the minimum along a given axis.
|
| Refer to `numpy.amin` for full documentation.
|
| See Also
| --------
| numpy.amin : equivalent function
|
| nonzero(...)
| a.nonzero()
|
| Return the indices of the elements that are non-zero.
|
| Refer to `numpy.nonzero` for full documentation.
|
| See Also
| --------
| numpy.nonzero : equivalent function
|
| partition(...)
| a.partition(kth, axis=-1, kind='introselect', order=None)
|
| Partially sorts the elements in the array in such a way that the value of
| the element in k-th position is in the position it would be in a sorted
| array. In the output array, all elements smaller than the k-th element
| are located to the left of this element and all equal or greater are
| located to its right. The ordering of the elements in the two partitions
| on the either side of the k-th element in the output array is undefined.
|
| .. versionadded:: 1.8.0
|
| Parameters
| ----------
| kth : int or sequence of ints
| Element index to partition by. The kth element value will be in its
| final sorted position and all smaller elements will be moved before it
| and all equal or greater elements behind it.
| The order of all elements in the partitions is undefined.
| If provided with a sequence of kth it will partition all elements
| indexed by kth of them into their sorted position at once.
|
| .. deprecated:: 1.22.0
| Passing booleans as index is deprecated.
| axis : int, optional
| Axis along which to sort. Default is -1, which means sort along the
| last axis.
| kind : {'introselect'}, optional
| Selection algorithm. Default is 'introselect'.
| order : str or list of str, optional
| When `a` is an array with fields defined, this argument specifies
| which fields to compare first, second, etc. A single field can
| be specified as a string, and not all fields need to be specified,
| but unspecified fields will still be used, in the order in which
| they come up in the dtype, to break ties.
|
| See Also
| --------
| numpy.partition : Return a partitioned copy of an array.
| argpartition : Indirect partition.
| sort : Full sort.
|
| Notes
| -----
| See ``np.partition`` for notes on the different algorithms.
|
| Examples
| --------
| >>> import numpy as np
| >>> a = np.array([3, 4, 2, 1])
| >>> a.partition(3)
| >>> a
| array([2, 1, 3, 4]) # may vary
|
| >>> a.partition((1, 3))
| >>> a
| array([1, 2, 3, 4])
|
| prod(...)
| a.prod(axis=None, dtype=None, out=None, keepdims=False,
| initial=1, where=True)
|
| Return the product of the array elements over the given axis
|
| Refer to `numpy.prod` for full documentation.
|
| See Also
| --------
| numpy.prod : equivalent function
|
| put(...)
| a.put(indices, values, mode='raise')
|
| Set ``a.flat[n] = values[n]`` for all `n` in indices.
|
| Refer to `numpy.put` for full documentation.
|
| See Also
| --------
| numpy.put : equivalent function
|
| ravel(...)
| a.ravel([order])
|
| Return a flattened array.
|
| Refer to `numpy.ravel` for full documentation.
|
| See Also
| --------
| numpy.ravel : equivalent function
|
| ndarray.flat : a flat iterator on the array.
|
| repeat(...)
| a.repeat(repeats, axis=None)
|
| Repeat elements of an array.
|
| Refer to `numpy.repeat` for full documentation.
|
| See Also
| --------
| numpy.repeat : equivalent function
|
| reshape(...)
| a.reshape(shape, /, *, order='C', copy=None)
|
| Returns an array containing the same data with a new shape.
|
| Refer to `numpy.reshape` for full documentation.
|
| See Also
| --------
| numpy.reshape : equivalent function
|
| Notes
| -----
| Unlike the free function `numpy.reshape`, this method on `ndarray` allows
| the elements of the shape parameter to be passed in as separate arguments.
| For example, ``a.reshape(10, 11)`` is equivalent to
| ``a.reshape((10, 11))``.
|
| resize(...)
| a.resize(new_shape, refcheck=True)
|
| Change shape and size of array in-place.
|
| Parameters
| ----------
| new_shape : tuple of ints, or `n` ints
| Shape of resized array.
| refcheck : bool, optional
| If False, reference count will not be checked. Default is True.
|
| Returns
| -------
| None
|
| Raises
| ------
| ValueError
| If `a` does not own its own data or references or views to it exist,
| and the data memory must be changed.
| PyPy only: will always raise if the data memory must be changed, since
| there is no reliable way to determine if references or views to it
| exist.
|
| SystemError
| If the `order` keyword argument is specified. This behaviour is a
| bug in NumPy.
|
| See Also
| --------
| resize : Return a new array with the specified shape.
|
| Notes
| -----
| This reallocates space for the data area if necessary.
|
| Only contiguous arrays (data elements consecutive in memory) can be
| resized.
|
| The purpose of the reference count check is to make sure you
| do not use this array as a buffer for another Python object and then
| reallocate the memory. However, reference counts can increase in
| other ways so if you are sure that you have not shared the memory
| for this array with another Python object, then you may safely set
| `refcheck` to False.
|
| Examples
| --------
| Shrinking an array: array is flattened (in the order that the data are
| stored in memory), resized, and reshaped:
|
| >>> import numpy as np
|
| >>> a = np.array([[0, 1], [2, 3]], order='C')
| >>> a.resize((2, 1))
| >>> a
| array([[0],
| [1]])
|
| >>> a = np.array([[0, 1], [2, 3]], order='F')
| >>> a.resize((2, 1))
| >>> a
| array([[0],
| [2]])
|
| Enlarging an array: as above, but missing entries are filled with zeros:
|
| >>> b = np.array([[0, 1], [2, 3]])
| >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
| >>> b
| array([[0, 1, 2],
| [3, 0, 0]])
|
| Referencing an array prevents resizing...
|
| >>> c = a
| >>> a.resize((1, 1))
| Traceback (most recent call last):
| ...
| ValueError: cannot resize an array that references or is referenced ...
|
| Unless `refcheck` is False:
|
| >>> a.resize((1, 1), refcheck=False)
| >>> a
| array([[0]])
| >>> c
| array([[0]])
|
| round(...)
| a.round(decimals=0, out=None)
|
| Return `a` with each element rounded to the given number of decimals.
|
| Refer to `numpy.around` for full documentation.
|
| See Also
| --------
| numpy.around : equivalent function
|
| searchsorted(...)
| a.searchsorted(v, side='left', sorter=None)
|
| Find indices where elements of v should be inserted in a to maintain order.
|
| For full documentation, see `numpy.searchsorted`
|
| See Also
| --------
| numpy.searchsorted : equivalent function
|
| setfield(...)
| a.setfield(val, dtype, offset=0)
|
| Put a value into a specified place in a field defined by a data-type.
|
| Place `val` into `a`'s field defined by `dtype` and beginning `offset`
| bytes into the field.
|
| Parameters
| ----------
| val : object
| Value to be placed in field.
| dtype : dtype object
| Data-type of the field in which to place `val`.
| offset : int, optional
| The number of bytes into the field at which to place `val`.
|
| Returns
| -------
| None
|
| See Also
| --------
| getfield
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.eye(3)
| >>> x.getfield(np.float64)
| array([[1., 0., 0.],
| [0., 1., 0.],
| [0., 0., 1.]])
| >>> x.setfield(3, np.int32)
| >>> x.getfield(np.int32)
| array([[3, 3, 3],
| [3, 3, 3],
| [3, 3, 3]], dtype=int32)
| >>> x
| array([[1.0e+000, 1.5e-323, 1.5e-323],
| [1.5e-323, 1.0e+000, 1.5e-323],
| [1.5e-323, 1.5e-323, 1.0e+000]])
| >>> x.setfield(np.eye(3), np.int32)
| >>> x
| array([[1., 0., 0.],
| [0., 1., 0.],
| [0., 0., 1.]])
|
| setflags(...)
| a.setflags(write=None, align=None, uic=None)
|
| Set array flags WRITEABLE, ALIGNED, WRITEBACKIFCOPY,
| respectively.
|
| These Boolean-valued flags affect how numpy interprets the memory
| area used by `a` (see Notes below). The ALIGNED flag can only
| be set to True if the data is actually aligned according to the type.
| The WRITEBACKIFCOPY flag can never be set
| to True. The flag WRITEABLE can only be set to True if the array owns its
| own memory, or the ultimate owner of the memory exposes a writeable buffer
| interface, or is a string. (The exception for string is made so that
| unpickling can be done without copying memory.)
|
| Parameters
| ----------
| write : bool, optional
| Describes whether or not `a` can be written to.
| align : bool, optional
| Describes whether or not `a` is aligned properly for its type.
| uic : bool, optional
| Describes whether or not `a` is a copy of another "base" array.
|
| Notes
| -----
| Array flags provide information about how the memory area used
| for the array is to be interpreted. There are 7 Boolean flags
| in use, only three of which can be changed by the user:
| WRITEBACKIFCOPY, WRITEABLE, and ALIGNED.
|
| WRITEABLE (W) the data area can be written to;
|
| ALIGNED (A) the data and strides are aligned appropriately for the hardware
| (as determined by the compiler);
|
| WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
| by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
| called, the base array will be updated with the contents of this array.
|
| All flags can be accessed using the single (upper case) letter as well
| as the full name.
|
| Examples
| --------
| >>> import numpy as np
| >>> y = np.array([[3, 1, 7],
| ... [2, 0, 0],
| ... [8, 5, 9]])
| >>> y
| array([[3, 1, 7],
| [2, 0, 0],
| [8, 5, 9]])
| >>> y.flags
| C_CONTIGUOUS : True
| F_CONTIGUOUS : False
| OWNDATA : True
| WRITEABLE : True
| ALIGNED : True
| WRITEBACKIFCOPY : False
| >>> y.setflags(write=0, align=0)
| >>> y.flags
| C_CONTIGUOUS : True
| F_CONTIGUOUS : False
| OWNDATA : True
| WRITEABLE : False
| ALIGNED : False
| WRITEBACKIFCOPY : False
| >>> y.setflags(uic=1)
| Traceback (most recent call last):
| File "<stdin>", line 1, in <module>
| ValueError: cannot set WRITEBACKIFCOPY flag to True
|
| sort(...)
| a.sort(axis=-1, kind=None, order=None)
|
| Sort an array in-place. Refer to `numpy.sort` for full documentation.
|
| Parameters
| ----------
| axis : int, optional
| Axis along which to sort. Default is -1, which means sort along the
| last axis.
| kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
| Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
| and 'mergesort' use timsort under the covers and, in general, the
| actual implementation will vary with datatype. The 'mergesort' option
| is retained for backwards compatibility.
|
| .. versionchanged:: 1.15.0
| The 'stable' option was added.
|
| order : str or list of str, optional
| When `a` is an array with fields defined, this argument specifies
| which fields to compare first, second, etc. A single field can
| be specified as a string, and not all fields need be specified,
| but unspecified fields will still be used, in the order in which
| they come up in the dtype, to break ties.
|
| See Also
| --------
| numpy.sort : Return a sorted copy of an array.
| numpy.argsort : Indirect sort.
| numpy.lexsort : Indirect stable sort on multiple keys.
| numpy.searchsorted : Find elements in sorted array.
| numpy.partition: Partial sort.
|
| Notes
| -----
| See `numpy.sort` for notes on the different sorting algorithms.
|
| Examples
| --------
| >>> import numpy as np
| >>> a = np.array([[1,4], [3,1]])
| >>> a.sort(axis=1)
| >>> a
| array([[1, 4],
| [1, 3]])
| >>> a.sort(axis=0)
| >>> a
| array([[1, 3],
| [1, 4]])
|
| Use the `order` keyword to specify a field to use when sorting a
| structured array:
|
| >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
| >>> a.sort(order='y')
| >>> a
| array([(b'c', 1), (b'a', 2)],
| dtype=[('x', 'S1'), ('y', '<i8')])
|
| squeeze(...)
| a.squeeze(axis=None)
|
| Remove axes of length one from `a`.
|
| Refer to `numpy.squeeze` for full documentation.
|
| See Also
| --------
| numpy.squeeze : equivalent function
|
| std(...)
| a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)
|
| Returns the standard deviation of the array elements along given axis.
|
| Refer to `numpy.std` for full documentation.
|
| See Also
| --------
| numpy.std : equivalent function
|
| sum(...)
| a.sum(axis=None, dtype=None, out=None, keepdims=False, initial=0, where=True)
|
| Return the sum of the array elements over the given axis.
|
| Refer to `numpy.sum` for full documentation.
|
| See Also
| --------
| numpy.sum : equivalent function
|
| swapaxes(...)
| a.swapaxes(axis1, axis2)
|
| Return a view of the array with `axis1` and `axis2` interchanged.
|
| Refer to `numpy.swapaxes` for full documentation.
|
| See Also
| --------
| numpy.swapaxes : equivalent function
|
| take(...)
| a.take(indices, axis=None, out=None, mode='raise')
|
| Return an array formed from the elements of `a` at the given indices.
|
| Refer to `numpy.take` for full documentation.
|
| See Also
| --------
| numpy.take : equivalent function
|
| to_device(...)
|
| tobytes(...)
| a.tobytes(order='C')
|
| Construct Python bytes containing the raw data bytes in the array.
|
| Constructs Python bytes showing a copy of the raw contents of
| data memory. The bytes object is produced in C-order by default.
| This behavior is controlled by the ``order`` parameter.
|
| .. versionadded:: 1.9.0
|
| Parameters
| ----------
| order : {'C', 'F', 'A'}, optional
| Controls the memory layout of the bytes object. 'C' means C-order,
| 'F' means F-order, 'A' (short for *Any*) means 'F' if `a` is
| Fortran contiguous, 'C' otherwise. Default is 'C'.
|
| Returns
| -------
| s : bytes
| Python bytes exhibiting a copy of `a`'s raw data.
|
| See also
| --------
| frombuffer
| Inverse of this operation, construct a 1-dimensional array from Python
| bytes.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.array([[0, 1], [2, 3]], dtype='<u2')
| >>> x.tobytes()
| b'\x00\x00\x01\x00\x02\x00\x03\x00'
| >>> x.tobytes('C') == x.tobytes()
| True
| >>> x.tobytes('F')
| b'\x00\x00\x02\x00\x01\x00\x03\x00'
|
| tofile(...)
| a.tofile(fid, sep="", format="%s")
|
| Write array to a file as text or binary (default).
|
| Data is always written in 'C' order, independent of the order of `a`.
| The data produced by this method can be recovered using the function
| fromfile().
|
| Parameters
| ----------
| fid : file or str or Path
| An open file object, or a string containing a filename.
|
| .. versionchanged:: 1.17.0
| `pathlib.Path` objects are now accepted.
|
| sep : str
| Separator between array items for text output.
| If "" (empty), a binary file is written, equivalent to
| ``file.write(a.tobytes())``.
| format : str
| Format string for text file output.
| Each entry in the array is formatted to text by first converting
| it to the closest Python type, and then using "format" % item.
|
| Notes
| -----
| This is a convenience function for quick storage of array data.
| Information on endianness and precision is lost, so this method is not a
| good choice for files intended to archive data or transport data between
| machines with different endianness. Some of these problems can be overcome
| by outputting the data as text files, at the expense of speed and file
| size.
|
| When fid is a file object, array contents are directly written to the
| file, bypassing the file object's ``write`` method. As a result, tofile
| cannot be used with files objects supporting compression (e.g., GzipFile)
| or file-like objects that do not support ``fileno()`` (e.g., BytesIO).
|
| tolist(...)
| a.tolist()
|
| Return the array as an ``a.ndim``-levels deep nested list of Python scalars.
|
| Return a copy of the array data as a (nested) Python list.
| Data items are converted to the nearest compatible builtin Python type, via
| the `~numpy.ndarray.item` function.
|
| If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will
| not be a list at all, but a simple Python scalar.
|
| Parameters
| ----------
| none
|
| Returns
| -------
| y : object, or list of object, or list of list of object, or ...
| The possibly nested list of array elements.
|
| Notes
| -----
| The array may be recreated via ``a = np.array(a.tolist())``, although this
| may sometimes lose precision.
|
| Examples
| --------
| For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``,
| except that ``tolist`` changes numpy scalars to Python scalars:
|
| >>> import numpy as np
| >>> a = np.uint32([1, 2])
| >>> a_list = list(a)
| >>> a_list
| [1, 2]
| >>> type(a_list[0])
| <class 'numpy.uint32'>
| >>> a_tolist = a.tolist()
| >>> a_tolist
| [1, 2]
| >>> type(a_tolist[0])
| <class 'int'>
|
| Additionally, for a 2D array, ``tolist`` applies recursively:
|
| >>> a = np.array([[1, 2], [3, 4]])
| >>> list(a)
| [array([1, 2]), array([3, 4])]
| >>> a.tolist()
| [[1, 2], [3, 4]]
|
| The base case for this recursion is a 0D array:
|
| >>> a = np.array(1)
| >>> list(a)
| Traceback (most recent call last):
| ...
| TypeError: iteration over a 0-d array
| >>> a.tolist()
| 1
|
| tostring(...)
| a.tostring(order='C')
|
| A compatibility alias for `~ndarray.tobytes`, with exactly the same
| behavior.
|
| Despite its name, it returns :class:`bytes` not :class:`str`\ s.
|
| .. deprecated:: 1.19.0
|
| trace(...)
| a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
|
| Return the sum along diagonals of the array.
|
| Refer to `numpy.trace` for full documentation.
|
| See Also
| --------
| numpy.trace : equivalent function
|
| transpose(...)
| a.transpose(*axes)
|
| Returns a view of the array with axes transposed.
|
| Refer to `numpy.transpose` for full documentation.
|
| Parameters
| ----------
| axes : None, tuple of ints, or `n` ints
|
| * None or no argument: reverses the order of the axes.
|
| * tuple of ints: `i` in the `j`-th place in the tuple means that the
| array's `i`-th axis becomes the transposed array's `j`-th axis.
|
| * `n` ints: same as an n-tuple of the same ints (this form is
| intended simply as a "convenience" alternative to the tuple form).
|
| Returns
| -------
| p : ndarray
| View of the array with its axes suitably permuted.
|
| See Also
| --------
| transpose : Equivalent function.
| ndarray.T : Array property returning the array transposed.
| ndarray.reshape : Give a new shape to an array without changing its data.
|
| Examples
| --------
| >>> import numpy as np
| >>> a = np.array([[1, 2], [3, 4]])
| >>> a
| array([[1, 2],
| [3, 4]])
| >>> a.transpose()
| array([[1, 3],
| [2, 4]])
| >>> a.transpose((1, 0))
| array([[1, 3],
| [2, 4]])
| >>> a.transpose(1, 0)
| array([[1, 3],
| [2, 4]])
|
| >>> a = np.array([1, 2, 3, 4])
| >>> a
| array([1, 2, 3, 4])
| >>> a.transpose()
| array([1, 2, 3, 4])
|
| var(...)
| a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)
|
| Returns the variance of the array elements, along given axis.
|
| Refer to `numpy.var` for full documentation.
|
| See Also
| --------
| numpy.var : equivalent function
|
| view(...)
| a.view([dtype][, type])
|
| New view of array with the same data.
|
| .. note::
| Passing None for ``dtype`` is different from omitting the parameter,
| since the former invokes ``dtype(None)`` which is an alias for
| ``dtype('float64')``.
|
| Parameters
| ----------
| dtype : data-type or ndarray sub-class, optional
| Data-type descriptor of the returned view, e.g., float32 or int16.
| Omitting it results in the view having the same data-type as `a`.
| This argument can also be specified as an ndarray sub-class, which
| then specifies the type of the returned object (this is equivalent to
| setting the ``type`` parameter).
| type : Python type, optional
| Type of the returned view, e.g., ndarray or matrix. Again, omission
| of the parameter results in type preservation.
|
| Notes
| -----
| ``a.view()`` is used two different ways:
|
| ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
| of the array's memory with a different data-type. This can cause a
| reinterpretation of the bytes of memory.
|
| ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
| returns an instance of `ndarray_subclass` that looks at the same array
| (same shape, dtype, etc.) This does not cause a reinterpretation of the
| memory.
|
| For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
| bytes per entry than the previous dtype (for example, converting a regular
| array to a structured array), then the last axis of ``a`` must be
| contiguous. This axis will be resized in the result.
|
| .. versionchanged:: 1.23.0
| Only the last axis needs to be contiguous. Previously, the entire array
| had to be C-contiguous.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.array([(-1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
|
| Viewing array data using a different type and dtype:
|
| >>> nonneg = np.dtype([("a", np.uint8), ("b", np.uint8)])
| >>> y = x.view(dtype=nonneg, type=np.recarray)
| >>> x["a"]
| array([-1], dtype=int8)
| >>> y.a
| array([255], dtype=uint8)
|
| Creating a view on a structured array so it can be used in calculations
|
| >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
| >>> xv = x.view(dtype=np.int8).reshape(-1,2)
| >>> xv
| array([[1, 2],
| [3, 4]], dtype=int8)
| >>> xv.mean(0)
| array([2., 3.])
|
| Making changes to the view changes the underlying array
|
| >>> xv[0,1] = 20
| >>> x
| array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')])
|
| Using a view to convert an array to a recarray:
|
| >>> z = x.view(np.recarray)
| >>> z.a
| array([1, 3], dtype=int8)
|
| Views share data:
|
| >>> x[0] = (9, 10)
| >>> z[0]
| np.record((9, 10), dtype=[('a', 'i1'), ('b', 'i1')])
|
| Views that change the dtype size (bytes per entry) should normally be
| avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
|
| >>> x = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int16)
| >>> y = x[:, ::2]
| >>> y
| array([[1, 3],
| [4, 6]], dtype=int16)
| >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
| Traceback (most recent call last):
| ...
| ValueError: To change to a dtype of a different size, the last axis must be contiguous
| >>> z = y.copy()
| >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
| array([[(1, 3)],
| [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])
|
| However, views that change dtype are totally fine for arrays with a
| contiguous last axis, even if the rest of the axes are not C-contiguous:
|
| >>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
| >>> x.transpose(1, 0, 2).view(np.int16)
| array([[[ 256, 770],
| [3340, 3854]],
| <BLANKLINE>
| [[1284, 1798],
| [4368, 4882]],
| <BLANKLINE>
| [[2312, 2826],
| [5396, 5910]]], dtype=int16)
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...)
| a.__class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.ndarray` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.ndarray` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.ndarray[Any, np.dtype[Any]]
| numpy.ndarray[typing.Any, numpy.dtype[typing.Any]]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
| numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`
| w.r.t. its `dtype.type <numpy.dtype.type>`.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| T
| View of the transposed array.
|
| Same as ``self.transpose()``.
|
| Examples
| --------
| >>> import numpy as np
| >>> a = np.array([[1, 2], [3, 4]])
| >>> a
| array([[1, 2],
| [3, 4]])
| >>> a.T
| array([[1, 3],
| [2, 4]])
|
| >>> a = np.array([1, 2, 3, 4])
| >>> a
| array([1, 2, 3, 4])
| >>> a.T
| array([1, 2, 3, 4])
|
| See Also
| --------
| transpose
|
| __array_interface__
| Array protocol: Python side.
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: C-struct side.
|
| base
| Base object if memory is from some other object.
|
| Examples
| --------
| The base of an array that owns its memory is None:
|
| >>> import numpy as np
| >>> x = np.array([1,2,3,4])
| >>> x.base is None
| True
|
| Slicing creates a view, whose memory is shared with x:
|
| >>> y = x[2:]
| >>> y.base is x
| True
|
| ctypes
| An object to simplify the interaction of the array with the ctypes
| module.
|
| This attribute creates an object that makes it easier to use arrays
| when calling shared libraries with the ctypes module. The returned
| object has, among others, data, shape, and strides attributes (see
| Notes below) which themselves return ctypes objects that can be used
| as arguments to a shared library.
|
| Parameters
| ----------
| None
|
| Returns
| -------
| c : Python object
| Possessing attributes data, shape, strides, etc.
|
| See Also
| --------
| numpy.ctypeslib
|
| Notes
| -----
| Below are the public attributes of this object which were documented
| in "Guide to NumPy" (we have omitted undocumented public attributes,
| as well as documented private attributes):
|
| .. autoattribute:: numpy._core._internal._ctypes.data
| :noindex:
|
| .. autoattribute:: numpy._core._internal._ctypes.shape
| :noindex:
|
| .. autoattribute:: numpy._core._internal._ctypes.strides
| :noindex:
|
| .. automethod:: numpy._core._internal._ctypes.data_as
| :noindex:
|
| .. automethod:: numpy._core._internal._ctypes.shape_as
| :noindex:
|
| .. automethod:: numpy._core._internal._ctypes.strides_as
| :noindex:
|
| If the ctypes module is not available, then the ctypes attribute
| of array objects still returns something useful, but ctypes objects
| are not returned and errors may be raised instead. In particular,
| the object will still have the ``as_parameter`` attribute which will
| return an integer equal to the data attribute.
|
| Examples
| --------
| >>> import numpy as np
| >>> import ctypes
| >>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)
| >>> x
| array([[0, 1],
| [2, 3]], dtype=int32)
| >>> x.ctypes.data
| 31962608 # may vary
| >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32))
| <__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary
| >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents
| c_uint(0)
| >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents
| c_ulong(4294967296)
| >>> x.ctypes.shape
| <numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary
| >>> x.ctypes.strides
| <numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary
|
| data
| Python buffer object pointing to the start of the array's data.
|
| device
|
| dtype
| Data-type of the array's elements.
|
| .. warning::
|
| Setting ``arr.dtype`` is discouraged and may be deprecated in the
| future. Setting will replace the ``dtype`` without modifying the
| memory (see also `ndarray.view` and `ndarray.astype`).
|
| Parameters
| ----------
| None
|
| Returns
| -------
| d : numpy dtype object
|
| See Also
| --------
| ndarray.astype : Cast the values contained in the array to a new data-type.
| ndarray.view : Create a view of the same data but a different data-type.
| numpy.dtype
|
| Examples
| --------
| >>> x
| array([[0, 1],
| [2, 3]])
| >>> x.dtype
| dtype('int32')
| >>> type(x.dtype)
| <type 'numpy.dtype'>
|
| flags
| Information about the memory layout of the array.
|
| Attributes
| ----------
| C_CONTIGUOUS (C)
| The data is in a single, C-style contiguous segment.
| F_CONTIGUOUS (F)
| The data is in a single, Fortran-style contiguous segment.
| OWNDATA (O)
| The array owns the memory it uses or borrows it from another object.
| WRITEABLE (W)
| The data area can be written to. Setting this to False locks
| the data, making it read-only. A view (slice, etc.) inherits WRITEABLE
| from its base array at creation time, but a view of a writeable
| array may be subsequently locked while the base array remains writeable.
| (The opposite is not true, in that a view of a locked array may not
| be made writeable. However, currently, locking a base object does not
| lock any views that already reference it, so under that circumstance it
| is possible to alter the contents of a locked array via a previously
| created writeable view onto it.) Attempting to change a non-writeable
| array raises a RuntimeError exception.
| ALIGNED (A)
| The data and all elements are aligned appropriately for the hardware.
| WRITEBACKIFCOPY (X)
| This array is a copy of some other array. The C-API function
| PyArray_ResolveWritebackIfCopy must be called before deallocating
| to the base array will be updated with the contents of this array.
| FNC
| F_CONTIGUOUS and not C_CONTIGUOUS.
| FORC
| F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
| BEHAVED (B)
| ALIGNED and WRITEABLE.
| CARRAY (CA)
| BEHAVED and C_CONTIGUOUS.
| FARRAY (FA)
| BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
|
| Notes
| -----
| The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
| or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
| names are only supported in dictionary access.
|
| Only the WRITEBACKIFCOPY, WRITEABLE, and ALIGNED flags can be
| changed by the user, via direct assignment to the attribute or dictionary
| entry, or by calling `ndarray.setflags`.
|
| The array flags cannot be set arbitrarily:
|
| - WRITEBACKIFCOPY can only be set ``False``.
| - ALIGNED can only be set ``True`` if the data is truly aligned.
| - WRITEABLE can only be set ``True`` if the array owns its own memory
| or the ultimate owner of the memory exposes a writeable buffer
| interface or is a string.
|
| Arrays can be both C-style and Fortran-style contiguous simultaneously.
| This is clear for 1-dimensional arrays, but can also be true for higher
| dimensional arrays.
|
| Even for contiguous arrays a stride for a given dimension
| ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
| or the array has no elements.
| It does *not* generally hold that ``self.strides[-1] == self.itemsize``
| for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
| Fortran-style contiguous arrays is true.
|
| flat
| A 1-D iterator over the array.
|
| This is a `numpy.flatiter` instance, which acts similarly to, but is not
| a subclass of, Python's built-in iterator object.
|
| See Also
| --------
| flatten : Return a copy of the array collapsed into one dimension.
|
| flatiter
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.arange(1, 7).reshape(2, 3)
| >>> x
| array([[1, 2, 3],
| [4, 5, 6]])
| >>> x.flat[3]
| 4
| >>> x.T
| array([[1, 4],
| [2, 5],
| [3, 6]])
| >>> x.T.flat[3]
| 5
| >>> type(x.flat)
| <class 'numpy.flatiter'>
|
| An assignment example:
|
| >>> x.flat = 3; x
| array([[3, 3, 3],
| [3, 3, 3]])
| >>> x.flat[[1,4]] = 1; x
| array([[3, 1, 3],
| [3, 1, 3]])
|
| imag
| The imaginary part of the array.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.sqrt([1+0j, 0+1j])
| >>> x.imag
| array([ 0. , 0.70710678])
| >>> x.imag.dtype
| dtype('float64')
|
| itemset
|
| itemsize
| Length of one array element in bytes.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.array([1,2,3], dtype=np.float64)
| >>> x.itemsize
| 8
| >>> x = np.array([1,2,3], dtype=np.complex128)
| >>> x.itemsize
| 16
|
| mT
| View of the matrix transposed array.
|
| The matrix transpose is the transpose of the last two dimensions, even
| if the array is of higher dimension.
|
| .. versionadded:: 2.0
|
| Raises
| ------
| ValueError
| If the array is of dimension less than 2.
|
| Examples
| --------
| >>> import numpy as np
| >>> a = np.array([[1, 2], [3, 4]])
| >>> a
| array([[1, 2],
| [3, 4]])
| >>> a.mT
| array([[1, 3],
| [2, 4]])
|
| >>> a = np.arange(8).reshape((2, 2, 2))
| >>> a
| array([[[0, 1],
| [2, 3]],
| <BLANKLINE>
| [[4, 5],
| [6, 7]]])
| >>> a.mT
| array([[[0, 2],
| [1, 3]],
| <BLANKLINE>
| [[4, 6],
| [5, 7]]])
|
| nbytes
| Total bytes consumed by the elements of the array.
|
| Notes
| -----
| Does not include memory consumed by non-element attributes of the
| array object.
|
| See Also
| --------
| sys.getsizeof
| Memory consumed by the object itself without parents in case view.
| This does include memory consumed by non-element attributes.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.zeros((3,5,2), dtype=np.complex128)
| >>> x.nbytes
| 480
| >>> np.prod(x.shape) * x.itemsize
| 480
|
| ndim
| Number of array dimensions.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.array([1, 2, 3])
| >>> x.ndim
| 1
| >>> y = np.zeros((2, 3, 4))
| >>> y.ndim
| 3
|
| newbyteorder
|
| ptp
|
| real
| The real part of the array.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.sqrt([1+0j, 0+1j])
| >>> x.real
| array([ 1. , 0.70710678])
| >>> x.real.dtype
| dtype('float64')
|
| See Also
| --------
| numpy.real : equivalent function
|
| shape
| Tuple of array dimensions.
|
| The shape property is usually used to get the current shape of an array,
| but may also be used to reshape the array in-place by assigning a tuple of
| array dimensions to it. As with `numpy.reshape`, one of the new shape
| dimensions can be -1, in which case its value is inferred from the size of
| the array and the remaining dimensions. Reshaping an array in-place will
| fail if a copy is required.
|
| .. warning::
|
| Setting ``arr.shape`` is discouraged and may be deprecated in the
| future. Using `ndarray.reshape` is the preferred approach.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.array([1, 2, 3, 4])
| >>> x.shape
| (4,)
| >>> y = np.zeros((2, 3, 4))
| >>> y.shape
| (2, 3, 4)
| >>> y.shape = (3, 8)
| >>> y
| array([[ 0., 0., 0., 0., 0., 0., 0., 0.],
| [ 0., 0., 0., 0., 0., 0., 0., 0.],
| [ 0., 0., 0., 0., 0., 0., 0., 0.]])
| >>> y.shape = (3, 6)
| Traceback (most recent call last):
| File "<stdin>", line 1, in <module>
| ValueError: total size of new array must be unchanged
| >>> np.zeros((4,2))[::2].shape = (-1,)
| Traceback (most recent call last):
| File "<stdin>", line 1, in <module>
| AttributeError: Incompatible shape for in-place modification. Use
| `.reshape()` to make a copy with the desired shape.
|
| See Also
| --------
| numpy.shape : Equivalent getter function.
| numpy.reshape : Function similar to setting ``shape``.
| ndarray.reshape : Method similar to setting ``shape``.
|
| size
| Number of elements in the array.
|
| Equal to ``np.prod(a.shape)``, i.e., the product of the array's
| dimensions.
|
| Notes
| -----
| `a.size` returns a standard arbitrary precision Python integer. This
| may not be the case with other methods of obtaining the same value
| (like the suggested ``np.prod(a.shape)``, which returns an instance
| of ``np.int_``), and may be relevant if the value is used further in
| calculations that may overflow a fixed size integer type.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
| >>> x.size
| 30
| >>> np.prod(x.shape)
| 30
|
| strides
| Tuple of bytes to step in each dimension when traversing an array.
|
| The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
| is::
|
| offset = sum(np.array(i) * a.strides)
|
| A more detailed explanation of strides can be found in
| :ref:`arrays.ndarray`.
|
| .. warning::
|
| Setting ``arr.strides`` is discouraged and may be deprecated in the
| future. `numpy.lib.stride_tricks.as_strided` should be preferred
| to create a new view of the same data in a safer way.
|
| Notes
| -----
| Imagine an array of 32-bit integers (each 4 bytes)::
|
| x = np.array([[0, 1, 2, 3, 4],
| [5, 6, 7, 8, 9]], dtype=np.int32)
|
| This array is stored in memory as 40 bytes, one after the other
| (known as a contiguous block of memory). The strides of an array tell
| us how many bytes we have to skip in memory to move to the next position
| along a certain axis. For example, we have to skip 4 bytes (1 value) to
| move to the next column, but 20 bytes (5 values) to get to the same
| position in the next row. As such, the strides for the array `x` will be
| ``(20, 4)``.
|
| See Also
| --------
| numpy.lib.stride_tricks.as_strided
|
| Examples
| --------
| >>> import numpy as np
| >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
| >>> y
| array([[[ 0, 1, 2, 3],
| [ 4, 5, 6, 7],
| [ 8, 9, 10, 11]],
| [[12, 13, 14, 15],
| [16, 17, 18, 19],
| [20, 21, 22, 23]]])
| >>> y.strides
| (48, 16, 4)
| >>> y[1,1,1]
| 17
| >>> offset=sum(y.strides * np.array((1,1,1)))
| >>> offset/y.itemsize
| 17
|
| >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
| >>> x.strides
| (32, 4, 224, 1344)
| >>> i = np.array([3,5,2,2])
| >>> offset = sum(i * x.strides)
| >>> x[3,5,2,2]
| 813
| >>> offset / x.itemsize
| 813
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
pyvista.OBJReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.OBJWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.OFF_SCREEN
Python Library Documentation: bool object class bool(int) | bool(x) -> bool | | Returns True when the argument x is true, False otherwise. | The builtins True and False are the only two instances of the class bool. | The class bool is a subclass of the class int, and cannot be subclassed. | | Method resolution order: | bool | int | object | | Methods defined here: | | __and__(self, value, /) | Return self&value. | | __invert__(self, /) | ~self | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __repr__(self, /) | Return repr(self). | | __ror__(self, value, /) | Return value|self. | | __rxor__(self, value, /) | Return value^self. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from int: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | True if self else False | | __ceil__(...) | Ceiling of an Integral returns itself. | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floor__(...) | Flooring an Integral returns itself. | | __floordiv__(self, value, /) | Return self//value. | | __format__(self, format_spec, /) | Convert to a string according to format_spec. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(self, /) | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __round__(...) | Rounding an Integral returns itself. | | Rounding with an ndigits argument also returns an integer. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __sizeof__(self, /) | Returns size in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __trunc__(...) | Truncating an Integral returns itself. | | as_integer_ratio(self, /) | Return a pair of integers, whose ratio is equal to the original int. | | The ratio is in lowest terms and has a positive denominator. | | >>> (10).as_integer_ratio() | (10, 1) | >>> (-10).as_integer_ratio() | (-10, 1) | >>> (0).as_integer_ratio() | (0, 1) | | bit_count(self, /) | Number of ones in the binary representation of the absolute value of self. | | Also known as the population count. | | >>> bin(13) | '0b1101' | >>> (13).bit_count() | 3 | | bit_length(self, /) | Number of bits necessary to represent self in binary. | | >>> bin(37) | '0b100101' | >>> (37).bit_length() | 6 | | conjugate(...) | Returns self, the complex conjugate of any int. | | is_integer(self, /) | Returns True. Exists for duck type compatibility with float.is_integer. | | to_bytes(self, /, length=1, byteorder='big', *, signed=False) | Return an array of bytes representing an integer. | | length | Length of bytes object to use. An OverflowError is raised if the | integer is not representable with the given number of bytes. Default | is length 1. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Determines whether two's complement is used to represent the integer. | If signed is False and a negative integer is given, an OverflowError | is raised. | | ---------------------------------------------------------------------- | Class methods inherited from int: | | from_bytes(bytes, byteorder='big', *, signed=False) | Return the integer represented by the given array of bytes. | | bytes | Holds the array of bytes to convert. The argument must either | support the buffer protocol or be an iterable object producing bytes. | Bytes and bytearray are examples of built-in objects that support the | buffer protocol. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Indicates whether two's complement is used to represent the integer. | | ---------------------------------------------------------------------- | Data descriptors inherited from int: | | denominator | the denominator of a rational number in lowest terms | | imag | the imaginary part of a complex number | | numerator | the numerator of a rational number in lowest terms | | real | the real part of a complex number
pyvista.ON_SCREENSHOT
Python Library Documentation: bool object class bool(int) | bool(x) -> bool | | Returns True when the argument x is true, False otherwise. | The builtins True and False are the only two instances of the class bool. | The class bool is a subclass of the class int, and cannot be subclassed. | | Method resolution order: | bool | int | object | | Methods defined here: | | __and__(self, value, /) | Return self&value. | | __invert__(self, /) | ~self | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __repr__(self, /) | Return repr(self). | | __ror__(self, value, /) | Return value|self. | | __rxor__(self, value, /) | Return value^self. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from int: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | True if self else False | | __ceil__(...) | Ceiling of an Integral returns itself. | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floor__(...) | Flooring an Integral returns itself. | | __floordiv__(self, value, /) | Return self//value. | | __format__(self, format_spec, /) | Convert to a string according to format_spec. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(self, /) | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __round__(...) | Rounding an Integral returns itself. | | Rounding with an ndigits argument also returns an integer. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __sizeof__(self, /) | Returns size in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __trunc__(...) | Truncating an Integral returns itself. | | as_integer_ratio(self, /) | Return a pair of integers, whose ratio is equal to the original int. | | The ratio is in lowest terms and has a positive denominator. | | >>> (10).as_integer_ratio() | (10, 1) | >>> (-10).as_integer_ratio() | (-10, 1) | >>> (0).as_integer_ratio() | (0, 1) | | bit_count(self, /) | Number of ones in the binary representation of the absolute value of self. | | Also known as the population count. | | >>> bin(13) | '0b1101' | >>> (13).bit_count() | 3 | | bit_length(self, /) | Number of bits necessary to represent self in binary. | | >>> bin(37) | '0b100101' | >>> (37).bit_length() | 6 | | conjugate(...) | Returns self, the complex conjugate of any int. | | is_integer(self, /) | Returns True. Exists for duck type compatibility with float.is_integer. | | to_bytes(self, /, length=1, byteorder='big', *, signed=False) | Return an array of bytes representing an integer. | | length | Length of bytes object to use. An OverflowError is raised if the | integer is not representable with the given number of bytes. Default | is length 1. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Determines whether two's complement is used to represent the integer. | If signed is False and a negative integer is given, an OverflowError | is raised. | | ---------------------------------------------------------------------- | Class methods inherited from int: | | from_bytes(bytes, byteorder='big', *, signed=False) | Return the integer represented by the given array of bytes. | | bytes | Holds the array of bytes to convert. The argument must either | support the buffer protocol or be an iterable object producing bytes. | Bytes and bytearray are examples of built-in objects that support the | buffer protocol. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Indicates whether two's complement is used to represent the integer. | | ---------------------------------------------------------------------- | Data descriptors inherited from int: | | denominator | the denominator of a rational number in lowest terms | | imag | the imaginary part of a complex number | | numerator | the numerator of a rational number in lowest terms | | real | the real part of a complex number
pyvista.Observer
Python Library Documentation: class Observer in module pyvista.core.utilities.observers
class Observer(pyvista.core.utilities.misc._NoNewAttrMixin)
| Observer(*args, **kwargs) -> '_T'
|
| A standard class for observing VTK objects.
|
| Method resolution order:
| Observer
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| __call__(self, _obj, _event, message) -> 'None'
| Declare standard call function for the observer.
|
| On an event occurrence, this function executes.
|
| __init__(self, event_type='ErrorEvent', log: 'bool' = True, store_history: 'bool' = False) -> 'None'
| Initialize observer.
|
| get_message(self, etc: 'bool' = False)
| Get the last set error message.
|
| Returns
| -------
| str
| The last set error message.
|
| has_event_occurred(self)
| Ask self if an error has occurred since last queried.
|
| This resets the observer's status.
|
| log_message(self, kind, alert) -> 'None'
| Parse different event types and passes them to logging.
|
| observe(self, algorithm)
| Make this an observer of an algorithm.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| parse_message(message) -> 'VtkEvent'
| Parse the given message.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
pyvista.Octahedron
Python Library Documentation: function Octahedron in module pyvista.core.utilities.geometric_objects
Octahedron(radius: 'float' = 1.0, center: 'VectorLike[float]' = (0.0, 0.0, 0.0)) -> 'PolyData'
Create an octahedron of a given size.
An octahedron is composed of eight congruent equilateral
triangles.
Parameters
----------
radius : float, default: 1.0
The radius of the circumscribed sphere for the octahedron.
center : sequence[float], default: (0.0, 0.0, 0.0)
Three-length sequence defining the center of the octahedron.
Returns
-------
pyvista.PolyData
Mesh for the octahedron. Cell scalars are defined that assign
integer labels to each face (with array name ``"FaceIndex"``).
Examples
--------
Create and plot an octahedron.
>>> import pyvista as pv
>>> tetra = pv.Octahedron()
>>> tetra.plot(categories=True)
See :ref:`create_platonic_solids_example` for more examples using this filter.
pyvista.OpenFOAMReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.OrthogonalPlanesSource
Python Library Documentation: class OrthogonalPlanesSource in module pyvista.core.utilities.geometric_sources
class OrthogonalPlanesSource(pyvista.core.utilities.misc._NoNewAttrMixin)
| OrthogonalPlanesSource(*args, **kwargs) -> '_T'
|
| Orthogonal planes source.
|
| This source generates three orthogonal planes. The :attr:`output` is a
| :class:`~pyvista.MultiBlock` with named plane meshes ``'yz'``, ``'zx'``, ``'xy'``.
| The meshes are ordered such that the first, second, and third plane is perpendicular
| to the x, y, and z-axis, respectively.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| bounds : VectorLike[float], default: (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0)
| Specify the bounds of the planes in the form:
| ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| The generated planes are centered in these bounds.
|
| resolution : int | VectorLike[int], default: 2
| Number of points on the planes in the x-y-z directions. Use a single number
| for a uniform resolution, or three values to set independent resolutions.
|
| normal_sign : '+' | '-' | sequence['+' | '-'], default: '+'
| Sign of the plane's normal vectors. Use a single value to set all normals to
| the same sign, or three values to set them independently.
|
| names : sequence[str], default: ('xy','yz','zx')
| Name of each plane in the generated :class:`~pyvista.MultiBlock`.
|
| Examples
| --------
| Generate default orthogonal planes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> planes_source = pv.OrthogonalPlanesSource()
| >>> output = planes_source.output
| >>> output.plot()
|
| Modify the planes to fit a mesh's bounds.
|
| >>> human = examples.download_human()
| >>> planes_source.bounds = human.bounds
| >>> planes_source.update()
|
| Plot the mesh and the planes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(human, scalars='Color', rgb=True)
| >>> _ = pl.add_mesh(output, opacity=0.3, show_edges=True)
| >>> pl.show()
|
| The planes are centered geometrically, but the frontal plane is positioned a bit
| too far forward. Use :meth:`push` to move the frontal plane.
|
| >>> planes_source.push(0.0, -10.0, 0)
| >>> planes_source.update()
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(human, scalars='Color', rgb=True)
| >>> _ = pl.add_mesh(output, opacity=0.3, show_edges=True, line_width=10)
| >>> pl.view_yz()
| >>> pl.show()
|
| Method resolution order:
| OrthogonalPlanesSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'OrthogonalPlanesSource', bounds: 'VectorLike[float]' = (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0), *, resolution: 'int | VectorLike[int]' = 2, normal_sign: "Literal['+', '-'] | Sequence[str]" = '+', names: 'Sequence[str]' = ('yz', 'zx', 'xy')) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| push(self: 'OrthogonalPlanesSource', *distance: 'float | VectorLike[float]') -> 'None'
| Translate each plane by the specified distance along its normal.
|
| Internally, this method calls :meth:`pyvista.PlaneSource.push` on each
| plane source.
|
| Parameters
| ----------
| *distance : float | VectorLike[float], default: (0.0, 0.0, 0.0)
| Distance to move each plane.
|
| update(self: 'OrthogonalPlanesSource') -> 'None'
| Update the output of the source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output of the source.
|
| The output is a :class:`pyvista.MultiBlock` with three blocks: one for each
| plane. The blocks are named ``'yz'``, ``'zx'``, ``'xy'``, and are ordered such
| that the first, second, and third plane is perpendicular to the x, y, and
| z-axis, respectively.
|
| The source is automatically updated by :meth:`update` prior to returning
| the output.
|
| Returns
| -------
| pyvista.MultiBlock
| Composite mesh with three planes.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| bounds
| Return or set the bounds of the planes.
|
| names
| Return or set the names of the planes.
|
| normal_sign
| Return or set the sign of the plane's normal vectors.
|
| resolution
| Return or set the resolution of the planes.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
pyvista.PDBReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.PICKLE_FORMAT
Python Library Documentation: package vtk
NAME
vtk - This is the vtk module
PACKAGE CONTENTS
all
generate_pyi
gtk (package)
numpy_interface (package)
qt (package)
test (package)
tk (package)
util (package)
vtkAcceleratorsVTKmCore
vtkAcceleratorsVTKmDataModel
vtkAcceleratorsVTKmFilters
vtkChartsCore
vtkCommonColor
vtkCommonComputationalGeometry
vtkCommonCore
vtkCommonDataModel
vtkCommonExecutionModel
vtkCommonMath
vtkCommonMisc
vtkCommonPython
vtkCommonSystem
vtkCommonTransforms
vtkDomainsChemistry
vtkDomainsChemistryOpenGL2
vtkFiltersAMR
vtkFiltersCellGrid
vtkFiltersCore
vtkFiltersExtraction
vtkFiltersFlowPaths
vtkFiltersGeneral
vtkFiltersGeneric
vtkFiltersGeometry
vtkFiltersGeometryPreview
vtkFiltersHybrid
vtkFiltersHyperTree
vtkFiltersImaging
vtkFiltersModeling
vtkFiltersParallel
vtkFiltersParallelDIY2
vtkFiltersParallelImaging
vtkFiltersParallelStatistics
vtkFiltersPoints
vtkFiltersProgrammable
vtkFiltersPython
vtkFiltersReduction
vtkFiltersSMP
vtkFiltersSelection
vtkFiltersSources
vtkFiltersStatistics
vtkFiltersTemporal
vtkFiltersTensor
vtkFiltersTexture
vtkFiltersTopology
vtkFiltersVerdict
vtkGeovisCore
vtkIOAMR
vtkIOAsynchronous
vtkIOAvmesh
vtkIOCGNSReader
vtkIOCONVERGECFD
vtkIOCellGrid
vtkIOCesium3DTiles
vtkIOChemistry
vtkIOCityGML
vtkIOCore
vtkIOERF
vtkIOEnSight
vtkIOEngys
vtkIOExodus
vtkIOExport
vtkIOExportGL2PS
vtkIOExportPDF
vtkIOFDS
vtkIOFLUENTCFF
vtkIOGeoJSON
vtkIOGeometry
vtkIOH5Rage
vtkIOH5part
vtkIOHDF
vtkIOIOSS
vtkIOImage
vtkIOImport
vtkIOInfovis
vtkIOLANLX3D
vtkIOLSDyna
vtkIOLegacy
vtkIOMINC
vtkIOMotionFX
vtkIOMovie
vtkIONetCDF
vtkIOOMF
vtkIOOggTheora
vtkIOPIO
vtkIOPLY
vtkIOParallel
vtkIOParallelExodus
vtkIOParallelLSDyna
vtkIOParallelXML
vtkIOSQL
vtkIOSegY
vtkIOTRUCHAS
vtkIOTecplotTable
vtkIOVPIC
vtkIOVeraOut
vtkIOVideo
vtkIOXML
vtkIOXMLParser
vtkIOXdmf2
vtkImagingColor
vtkImagingCore
vtkImagingFourier
vtkImagingGeneral
vtkImagingHybrid
vtkImagingMath
vtkImagingMorphological
vtkImagingOpenGL2
vtkImagingSources
vtkImagingStatistics
vtkImagingStencil
vtkInfovisCore
vtkInfovisLayout
vtkInteractionImage
vtkInteractionStyle
vtkInteractionWidgets
vtkParallelCore
vtkPythonContext2D
vtkRenderingAnnotation
vtkRenderingCellGrid
vtkRenderingContext2D
vtkRenderingContextOpenGL2
vtkRenderingCore
vtkRenderingExternal
vtkRenderingFreeType
vtkRenderingGL2PSOpenGL2
vtkRenderingGridAxes
vtkRenderingHyperTreeGrid
vtkRenderingImage
vtkRenderingLICOpenGL2
vtkRenderingLOD
vtkRenderingLabel
vtkRenderingMatplotlib
vtkRenderingOpenGL2
vtkRenderingOpenXR
vtkRenderingOpenXRRemoting
vtkRenderingParallel
vtkRenderingSceneGraph
vtkRenderingUI
vtkRenderingVR
vtkRenderingVRModels
vtkRenderingVolume
vtkRenderingVolumeAMR
vtkRenderingVolumeOpenGL2
vtkRenderingVtkJS
vtkSerializationManager
vtkTestingRendering
vtkTestingSerialization
vtkViewsContext2D
vtkViewsCore
vtkViewsInfovis
vtkWebCore
vtkWebGLExporter
web (package)
wx (package)
FUNCTIONS
buffer_shared(...)
Check if two objects share the same buffer, meaning that they point to the same block of memory. An TypeError exception will be raised if either of the objects does not provide a buffer.
DATA
AllComponents = -100
Cells = 0
Discontinuous = 1
IMPLICIT_STRUCTURED_MODE = 3
InverseJacobian = 0
L1Norm = -1
L2Norm = -2
LInfNorm = -99
NON_SPARSE_MODE = 2
None_ = 1
Requested = -101
SINGLE_PROCESS_MODE = 0
SPARSE_MODE = 1
ScaledJacobian = 2
SharedDOF = 0
Sides = 1
VTKIS_ACTOR = 1
VTKIS_ANIM_OFF = 0
VTKIS_ANIM_ON = 1
VTKIS_CAMERA = 0
VTKIS_CLIP = 11
VTKIS_DOLLY = 4
VTKIS_ELEVATION = 21
VTKIS_ENV_ROTATE = 19
VTKIS_EXIT = 15
VTKIS_FORWARDFLY = 8
VTKIS_GESTURE = 18
VTKIS_GROUNDMOVEMENT = 20
VTKIS_IMAGE2D = 2
VTKIS_IMAGE3D = 3
VTKIS_IMAGE_SLICING = 4
VTKIS_JOYSTICK = 0
VTKIS_LOAD_CAMERA_POSE = 13
VTKIS_MENU = 17
VTKIS_NONE = 0
VTKIS_PAN = 2
VTKIS_PICK = 12
VTKIS_POSITION_PROP = 14
VTKIS_REVERSEFLY = 9
VTKIS_ROTATE = 1
VTKIS_SLICE = 1025
VTKIS_SPIN = 3
VTKIS_START = 0
VTKIS_TELEPORTATION = 22
VTKIS_TIMER = 7
VTKIS_TOGGLE_DRAW_CONTROLS = 16
VTKIS_TRACKBALL = 1
VTKIS_TWO_POINTER = 10
VTKIS_USCALE = 6
VTKIS_USERINTERACTION = 8
VTKIS_WINDOW_LEVEL = 1024
VTKIS_ZOOM = 5
VTKI_MAX_POINTERS = 5
VTKI_TIMER_FIRST = 0
VTKI_TIMER_UPDATE = 1
VTKKW_FPMM_SHIFT = 17
VTKKW_FP_MASK = 32767.0
VTKKW_FP_SCALE = 32767.0
VTKKW_FP_SHIFT = 15
VTKM_DATA_ARRAY = 8
VTK_21_POINT_WEDGE = True
VTK_3D_EXTENT = 1
VTK_ABS = 9
VTK_ABSTRACT_ARRAY = 0
VTK_ABSTRACT_ELECTRONIC_DATA = 42
VTK_ACCUMULATION_MODE_MAX = 1
VTK_ACCUMULATION_MODE_MIN = 0
VTK_ACCUMULATION_MODE_SUM = 2
VTK_ADD = 0
VTK_ADDC = 17
VTK_AFFINE_ARRAY = 11
VTK_AMR_DATA_OBJECT = 50
VTK_AND = 0
VTK_ANNOTATION = 44
VTK_ANNOTATION_LAYERS = 45
VTK_AOS_DATA_ARRAY = 5
VTK_ARIAL = 0
VTK_ARRAY_DATA = 27
VTK_ARROW_GLYPH = 9
VTK_ASCII = 1
VTK_ATAN = 14
VTK_ATAN2 = 15
VTK_ATTRIBUTE_MODE_DEFAULT = 0
VTK_ATTRIBUTE_MODE_USE_CELL_DATA = 2
VTK_ATTRIBUTE_MODE_USE_POINT_DATA = 1
VTK_BACKGROUND_LOCATION = 0
VTK_BEST_FITTING_PLANE = 2
VTK_BEZIER_CURVE = 75
VTK_BEZIER_HEXAHEDRON = 79
VTK_BEZIER_PYRAMID = 81
VTK_BEZIER_QUADRILATERAL = 77
VTK_BEZIER_TETRAHEDRON = 78
VTK_BEZIER_TRIANGLE = 76
VTK_BEZIER_WEDGE = 80
VTK_BIG_ENDIAN = 1
VTK_BINARY = 2
VTK_BIQUADRATIC_QUAD = 28
VTK_BIQUADRATIC_QUADRATIC_HEXAHEDRON = 33
VTK_BIQUADRATIC_QUADRATIC_WEDGE = 32
VTK_BIQUADRATIC_TRIANGLE = 34
VTK_BIT = 1
VTK_BIT_ARRAY = 4
VTK_BIT_MAX = 1
VTK_BIT_MIN = 0
VTK_BLACKMAN_HARRIS3 = 6
VTK_BLACKMAN_HARRIS4 = 7
VTK_BLACKMAN_NUTTALL3 = 9
VTK_BLACKMAN_NUTTALL4 = 10
VTK_BLACKMAN_WINDOW = 5
VTK_BOX_TYPE_AXIS_ALIGNED = 0
VTK_BOX_TYPE_ORIENTED = 1
VTK_BSPLINE_EDGE = 0
VTK_BSPLINE_ZERO = 1
VTK_BSPLINE_ZERO_AT_BORDER = 2
VTK_BSP_CUTS = 46
VTK_BUILD_VERSION = 2
VTK_BUNYKRCF_ARRAY_SIZE = 10000
VTK_BUNYKRCF_MAX_ARRAYS = 10000
VTK_CARTESIAN_GRID = 51
VTK_CCS_SCALAR_MODE_COLORS = 1
VTK_CCS_SCALAR_MODE_LABELS = 2
VTK_CCS_SCALAR_MODE_NONE = 0
VTK_CELL_DATA = 0
VTK_CELL_DATA_FIELD = 2
VTK_CELL_GRID = 49
VTK_CELL_MODE = 1
VTK_CELL_SIZE = 512
VTK_CHAR = 2
VTK_CHAR_MAX = 127
VTK_CHAR_MIN = -128
VTK_CIRCLE_GLYPH = 7
VTK_COLOR_BY_INPUT = 0
VTK_COLOR_BY_SCALAR = 1
VTK_COLOR_BY_SCALE = 0
VTK_COLOR_BY_SOURCE = 1
VTK_COLOR_BY_VECTOR = 2
VTK_COLOR_MODE_DEFAULT = 0
VTK_COLOR_MODE_DIRECT_SCALARS = 2
VTK_COLOR_MODE_LINEAR_256 = 1
VTK_COLOR_MODE_LUT = 0
VTK_COLOR_MODE_MAP_SCALARS = 1
VTK_COLOR_MODE_OFF = 4
VTK_COLOR_MODE_UNIFORM_CELL_COLOR = 1
VTK_COLOR_MODE_UNIFORM_COLOR = 3
VTK_COLOR_MODE_UNIFORM_POINT_COLOR = 2
VTK_COMPLEX_MULTIPLY = 19
VTK_COMPONENT_MODE_USE_ALL = 1
VTK_COMPONENT_MODE_USE_ANY = 2
VTK_COMPONENT_MODE_USE_SELECTED = 0
VTK_COMPOSITE_ARRAY = 12
VTK_COMPOSITE_DATA_SET = 11
VTK_CONJUGATE = 18
VTK_CONSTANT_ARRAY = 13
VTK_CONVEX_POINT_SET = 41
VTK_COS = 6
VTK_COSINE_WINDOW = 2
VTK_COURIER = 1
VTK_CROP_CROSS = 4289552
VTK_CROP_FENCE = 49020602
VTK_CROP_INVERTED_CROSS = 129928175.0
VTK_CROP_INVERTED_FENCE = 85197125
VTK_CROP_SUBVOLUME = 8192
VTK_CROSS_GLYPH = 3
VTK_CTF_DIVERGING = 3
VTK_CTF_HSV = 1
VTK_CTF_LAB = 2
VTK_CTF_LAB_CIEDE2000 = 4
VTK_CTF_LINEAR = 0
VTK_CTF_LOG10 = 1
VTK_CTF_PROLAB = 6
VTK_CTF_RGB = 0
VTK_CTF_STEP = 5
VTK_CUBIC_INTERPOLATION = 2
VTK_CUBIC_LINE = 35
VTK_CUBIC_RESLICE = 2
VTK_CULLER_SORT_BACK_TO_FRONT = 2
VTK_CULLER_SORT_FRONT_TO_BACK = 1
VTK_CULLER_SORT_NONE = 0
VTK_CURSOR_ARROW = 1
VTK_CURSOR_CROSSHAIR = 10
VTK_CURSOR_CUSTOM = 11
VTK_CURSOR_DEFAULT = 0
VTK_CURSOR_HAND = 9
VTK_CURSOR_SIZEALL = 8
VTK_CURSOR_SIZENE = 2
VTK_CURSOR_SIZENS = 6
VTK_CURSOR_SIZENW = 3
VTK_CURSOR_SIZESE = 5
VTK_CURSOR_SIZESW = 4
VTK_CURSOR_SIZEWE = 7
VTK_CURVATURE_GAUSS = 0
VTK_CURVATURE_MAXIMUM = 2
VTK_CURVATURE_MEAN = 1
VTK_CURVATURE_MINIMUM = 3
VTK_DASH_GLYPH = 2
VTK_DATA_ARRAY = 1
VTK_DATA_OBJECT = 7
VTK_DATA_OBJECT_FIELD = 0
VTK_DATA_OBJECT_TREE = 41
VTK_DATA_SCALING_OFF = 3
VTK_DATA_SET = 8
VTK_DBL_EPSILON = 2.220446049250313e-16
VTK_DBL_MIN = 2.2250738585072014e-308
VTK_DELAUNAY_XY_PLANE = 0
VTK_DENSITY_ESTIMATE_FIXED_RADIUS = 0
VTK_DENSITY_ESTIMATE_RELATIVE_RADIUS = 1
VTK_DENSITY_FORM_NPTS = 1
VTK_DENSITY_FORM_VOLUME_NORM = 0
VTK_DEPRECATION_LEVEL = 90600000002
VTK_DIAMOND_GLYPH = 8
VTK_DICE_MODE_MEMORY_LIMIT = 2
VTK_DICE_MODE_NUMBER_OF_POINTS = 0
VTK_DICE_MODE_SPECIFIED_NUMBER = 1
VTK_DIJKSTRA_EDGE_SEARCH = 1
VTK_DIRECTED_ACYCLIC_GRAPH = 26
VTK_DIRECTED_GRAPH = 23
VTK_DISPLAY = 0
VTK_DIVIDE = 3
VTK_DOUBLE = 11
VTK_DOUBLE_MAX = 1e+299
VTK_DOUBLE_MIN = -1e+299
VTK_EDGEARROW_GLYPH = 12
VTK_EDGE_OVERLAP = 2
VTK_EDT_SAITO = 1
VTK_EDT_SAITO_CACHED = 0
VTK_EMPTY = 9
VTK_EMPTY_CELL = 0
VTK_ENCODING_ISO_8859_1 = 4
VTK_ENCODING_ISO_8859_10 = 13
VTK_ENCODING_ISO_8859_11 = 14
VTK_ENCODING_ISO_8859_12 = 15
VTK_ENCODING_ISO_8859_13 = 16
VTK_ENCODING_ISO_8859_14 = 17
VTK_ENCODING_ISO_8859_15 = 18
VTK_ENCODING_ISO_8859_16 = 19
VTK_ENCODING_ISO_8859_2 = 5
VTK_ENCODING_ISO_8859_3 = 6
VTK_ENCODING_ISO_8859_4 = 7
VTK_ENCODING_ISO_8859_5 = 8
VTK_ENCODING_ISO_8859_6 = 9
VTK_ENCODING_ISO_8859_7 = 10
VTK_ENCODING_ISO_8859_8 = 11
VTK_ENCODING_ISO_8859_9 = 12
VTK_ENCODING_NONE = 0
VTK_ENCODING_UNICODE = 2
VTK_ENCODING_UNKNOWN = 20
VTK_ENCODING_US_ASCII = 1
VTK_ENCODING_UTF_8 = 3
VTK_EPOCH_VERSION = 2
VTK_ERROR = 2
VTK_ERROR_ABSOLUTE = 2
VTK_ERROR_NUMBER_OF_TRIANGLES = 0
VTK_ERROR_RELATIVE = 3
VTK_ERROR_SPECIFIED_REDUCTION = 1
VTK_EXP = 7
VTK_EXPLICIT_STRUCTURED_GRID = 40
VTK_EXTRACT_ALL_CLUSTERS = 4
VTK_EXTRACT_ALL_REGIONS = 5
VTK_EXTRACT_CELL_SEEDED_REGIONS = 2
VTK_EXTRACT_CLOSEST_POINT_CLUSTER = 5
VTK_EXTRACT_CLOSEST_POINT_REGION = 6
VTK_EXTRACT_COMPONENT = 0
VTK_EXTRACT_DETERMINANT = 2
VTK_EXTRACT_EFFECTIVE_STRESS = 1
VTK_EXTRACT_LARGEST_CLUSTER = 3
VTK_EXTRACT_LARGEST_REGION = 4
VTK_EXTRACT_LARGE_REGIONS = 7
VTK_EXTRACT_NONNEGATIVE_DETERMINANT = 3
VTK_EXTRACT_POINT_SEEDED_CLUSTERS = 1
VTK_EXTRACT_POINT_SEEDED_REGIONS = 1
VTK_EXTRACT_SPECIFIED_CLUSTERS = 2
VTK_EXTRACT_SPECIFIED_REGIONS = 3
VTK_EXTRACT_TRACE = 4
VTK_FILE_BYTE_ORDER_BIG_ENDIAN = 0
VTK_FILE_BYTE_ORDER_LITTLE_ENDIAN = 1
VTK_FLAT = 0
VTK_FLOAT = 10
VTK_FLOAT_MAX = 9.999999680285692e+37
VTK_FLOAT_MIN = -9.999999680285692e+37
VTK_FOLLOW_CAMERA_DIRECTION = 3
VTK_FONT_FILE = 4
VTK_FOREGROUND_LOCATION = 1
VTK_GENERIC_DATA_SET = 16
VTK_GEO_JSON_FEATURE = 47
VTK_GET_ARRAY_BY_ID = 0
VTK_GET_ARRAY_BY_NAME = 1
VTK_GOURAUD = 1
VTK_GRAPH = 20
VTK_GREEDY_EDGE_SEARCH = 0
VTK_GRID_CUBIC = 2
VTK_GRID_LINEAR = 1
VTK_GRID_NEAREST = 0
VTK_HAMMING_WINDOW = 4
VTK_HANN_WINDOW = 3
VTK_HAS_ABI_NAMESPACE = 0
VTK_HEXAGONAL_PRISM = 16
VTK_HEXAHEDRON = 12
VTK_HIERARCHICAL_BOX_DATA_SET = 15
VTK_HIERARCHICAL_DATA_SET = 14
VTK_HIGHER_ORDER_EDGE = 60
VTK_HIGHER_ORDER_HEXAHEDRON = 67
VTK_HIGHER_ORDER_POLYGON = 63
VTK_HIGHER_ORDER_PYRAMID = 66
VTK_HIGHER_ORDER_QUAD = 62
VTK_HIGHER_ORDER_TETRAHEDRON = 64
VTK_HIGHER_ORDER_TRIANGLE = 61
VTK_HIGHER_ORDER_WEDGE = 65
VTK_HOOKEDARROW_GLYPH = 11
VTK_HYPER_OCTREE = 17
VTK_HYPER_TREE_GRID = 32
VTK_ICON_GRAVITY_BOTTOM_CENTER = 8
VTK_ICON_GRAVITY_BOTTOM_LEFT = 9
VTK_ICON_GRAVITY_BOTTOM_RIGHT = 7
VTK_ICON_GRAVITY_CENTER_CENTER = 5
VTK_ICON_GRAVITY_CENTER_LEFT = 6
VTK_ICON_GRAVITY_CENTER_RIGHT = 4
VTK_ICON_GRAVITY_TOP_CENTER = 2
VTK_ICON_GRAVITY_TOP_LEFT = 3
VTK_ICON_GRAVITY_TOP_RIGHT = 1
VTK_ICON_SCALING_OFF = 0
VTK_ICON_SCALING_USE_SCALING_ARRAY = 1
VTK_ICP_MODE_AV = 1
VTK_ICP_MODE_RMS = 0
VTK_ID_MAX = 9223372036854775807
VTK_ID_MIN = -9223372036854775808
VTK_ID_TYPE = 12
VTK_ID_TYPE_IMPL = 16
VTK_ID_TYPE_PRId = 'lld'
VTK_IMAGE_BLEND_MODE_COMPOUND = 1
VTK_IMAGE_BLEND_MODE_NORMAL = 0
VTK_IMAGE_BORDER_CLAMP = 0
VTK_IMAGE_BORDER_MIRROR = 2
VTK_IMAGE_BORDER_REPEAT = 1
VTK_IMAGE_BSPLINE_DEGREE_MAX = 9
VTK_IMAGE_DATA = 6
VTK_IMAGE_NON_MAXIMUM_SUPPRESSION_MAGNITUDE_INPUT = 0
VTK_IMAGE_NON_MAXIMUM_SUPPRESSION_VECTOR_INPUT = 1
VTK_IMAGE_PLANE_WIDGET_MAX_TEXTBUFF = 128
VTK_IMAGE_SLAB_MAX = 1
VTK_IMAGE_SLAB_MEAN = 2
VTK_IMAGE_SLAB_MIN = 0
VTK_IMAGE_SLAB_SUM = 3
VTK_IMAGE_STENCIL_DATA = 48
VTK_IMPLICIT_ARRAY = 10
VTK_INDEXED_ARRAY = 14
VTK_INDEXING_BY_SCALAR = 1
VTK_INDEXING_BY_VECTOR = 2
VTK_INDEXING_OFF = 0
VTK_INSIDE_CLOSEST_POINT_REGION = 2
VTK_INSIDE_LARGEST_REGION = 1
VTK_INSIDE_SMALLEST_REGION = 0
VTK_INT = 6
VTK_INTEGRATE_BACKWARD = 1
VTK_INTEGRATE_BOTH_DIRECTIONS = 2
VTK_INTEGRATE_FORWARD = 0
VTK_INTEGRATE_MAJOR_EIGENVECTOR = 0
VTK_INTEGRATE_MEDIUM_EIGENVECTOR = 1
VTK_INTEGRATE_MINOR_EIGENVECTOR = 2
VTK_INT_MAX = 2147483647
VTK_INT_MIN = -2147483648
VTK_INVERT = 4
VTK_ITERATION_MODE_DIRECT_NB = 0
VTK_ITERATION_MODE_MAX = 1
VTK_ITW_PROJECTION_XY = 2
VTK_ITW_PROJECTION_XZ = 1
VTK_ITW_PROJECTION_YZ = 0
VTK_ITW_SNAP_CELLS = 0
VTK_ITW_SNAP_POINTS = 1
VTK_IV_COLUMN = 0
VTK_IV_ROW = 1
VTK_KAISER_WINDOW = 1
VTK_LABEL_FIELD_DATA = 6
VTK_LABEL_IDS = 0
VTK_LABEL_NORMALS = 3
VTK_LABEL_SCALARS = 1
VTK_LABEL_TCOORDS = 4
VTK_LABEL_TENSORS = 5
VTK_LABEL_VECTORS = 2
VTK_LAGRANGE_CURVE = 68
VTK_LAGRANGE_HEXAHEDRON = 72
VTK_LAGRANGE_PYRAMID = 74
VTK_LAGRANGE_QUADRILATERAL = 70
VTK_LAGRANGE_TETRAHEDRON = 71
VTK_LAGRANGE_TRIANGLE = 69
VTK_LAGRANGE_WEDGE = 73
VTK_LANCZOS_WINDOW = 0
VTK_LANDMARK_AFFINE = 12
VTK_LANDMARK_RIGIDBODY = 6
VTK_LANDMARK_SIMILARITY = 7
VTK_LIGHT_TYPE_CAMERA_LIGHT = 2
VTK_LIGHT_TYPE_HEADLIGHT = 1
VTK_LIGHT_TYPE_SCENE_LIGHT = 3
VTK_LINE = 3
VTK_LINEAR_INTERPOLATION = 1
VTK_LINEAR_RESLICE = 1
VTK_LITTLE_ENDIAN = 0
VTK_LOG = 8
VTK_LONG = 8
VTK_LONG_LONG = 16
VTK_LONG_LONG_MAX = 9223372036854775807
VTK_LONG_LONG_MIN = -9223372036854775808
VTK_LONG_MAX = 2147483647
VTK_LONG_MIN = -2147483648
VTK_LOOP_CLOSURE_ALL = 2
VTK_LOOP_CLOSURE_BOUNDARY = 1
VTK_LOOP_CLOSURE_OFF = 0
VTK_LSDYNA_BADFILE = 0
VTK_LUMINANCE = 1
VTK_LUMINANCE_ALPHA = 2
VTK_MAJOR_VERSION = 9
VTK_MARKER_CIRCLE = 4
VTK_MARKER_CROSS = 1
VTK_MARKER_DIAMOND = 5
VTK_MARKER_NONE = 0
VTK_MARKER_PLUS = 2
VTK_MARKER_SQUARE = 3
VTK_MARKER_UNKNOWN = 6
VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL = 'is internal'
VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT = 'is redundant'
VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED = '(de)serialization is not s...
VTK_MATERIALMODE_AMBIENT = 1
VTK_MATERIALMODE_AMBIENT_AND_DIFFUSE = 3
VTK_MATERIALMODE_DEFAULT = 0
VTK_MATERIALMODE_DIFFUSE = 2
VTK_MAX = 13
VTK_MAXPATH = 32767
VTK_MAX_ANNULUS_RESOLUTION = 2048
VTK_MAX_CIRCLE_RESOLUTION = 1024
VTK_MAX_CONE_RESOLUTION = 2048
VTK_MAX_CYL_RESOLUTION = 2048
VTK_MAX_LEVEL = 12
VTK_MAX_SHADING_TABLES = 100
VTK_MAX_SPHERE_RESOLUTION = 1024
VTK_MAX_SPHERE_TREE_LEVELS = 20
VTK_MAX_SPHERE_TREE_RESOLUTION = 10
VTK_MAX_SUPERQUADRIC_RESOLUTION = 1024
VTK_MAX_THREADS = 64
VTK_MAX_VRCOMP = 4
VTK_MIN = 12
VTK_MINIMUM_DEPRECATION_LEVEL = 90400000000
VTK_MINOR_VERSION = 6
VTK_MIN_SUPERQUADRIC_ROUNDNESS = 1e-24
VTK_MIN_SUPERQUADRIC_THICKNESS = 0.0001
VTK_MOLECULE = 33
VTK_MTIME_MAX = 18446744073709551615
VTK_MTIME_MIN = 0
VTK_MTIME_TYPE_IMPL = 17
VTK_MULTIBLOCK_DATA_SET = 13
VTK_MULTIGROUP_DATA_SET = 12
VTK_MULTIPIECE_DATA_SET = 25
VTK_MULTIPLY = 2
VTK_MULTIPLYBYK = 16
VTK_NAND = 3
VTK_NEAREST_INTERPOLATION = 0
VTK_NEAREST_RESLICE = 0
VTK_NODE_OVERLAP = 1
VTK_NON_OVERLAPPING_AMR = 30
VTK_NOP = 6
VTK_NOR = 4
VTK_NORMALIZED_DISPLAY = 1
VTK_NORMALIZED_VIEWPORT = 3
VTK_NORMAL_EXTRUSION = 2
VTK_NOT = 5
VTK_NO_GLYPH = 0
VTK_NO_OVERLAP = 0
VTK_NUMBER_OF_CELL_TYPES = 82
VTK_NUM_ARRAY_TYPES = 18
VTK_NUTTALL_WINDOW = 8
VTK_OBJECT = 21
VTK_OK = 1
VTK_ONLYCAMERA = 0
VTK_ONLYWIDGET = 1
VTK_OPAQUE = 14
VTK_OPENFOAM_TIME_PROFILING = 0
VTK_OPEN_QUBE_ELECTRONIC_DATA = 43
VTK_OR = 1
VTK_ORIENT_HORIZONTAL = 0
VTK_ORIENT_VERTICAL = 1
VTK_OUTPUT_BOTH = 2
VTK_OUTPUT_POLYGONS = 0
VTK_OUTPUT_POLYLINES = 1
VTK_OVERLAPPING_AMR = 31
VTK_PARAMETRIC_CURVE = 51
VTK_PARAMETRIC_HEX_REGION = 56
VTK_PARAMETRIC_QUAD_SURFACE = 54
VTK_PARAMETRIC_SURFACE = 52
VTK_PARAMETRIC_TETRA_REGION = 55
VTK_PARAMETRIC_TRI_SURFACE = 53
VTK_PARSEALL = 2
VTK_PARSER_ABSOLUTE_VALUE = 9
VTK_PARSER_ADD = 4
VTK_PARSER_AND = 48
VTK_PARSER_ARCCOSINE = 21
VTK_PARSER_ARCSINE = 20
VTK_PARSER_ARCTANGENT = 22
VTK_PARSER_BEGIN_VARIABLES = 50
VTK_PARSER_CEILING = 11
VTK_PARSER_COSINE = 18
VTK_PARSER_CROSS = 28
VTK_PARSER_DIVIDE = 7
VTK_PARSER_DOT_PRODUCT = 32
VTK_PARSER_EQUAL_TO = 47
VTK_PARSER_ERROR_RESULT = 9.999999680285692e+37
VTK_PARSER_EXPONENT = 10
VTK_PARSER_FLOOR = 12
VTK_PARSER_GREATER_THAN = 46
VTK_PARSER_HYPERBOLIC_COSINE = 24
VTK_PARSER_HYPERBOLIC_SINE = 23
VTK_PARSER_HYPERBOLIC_TANGENT = 25
VTK_PARSER_IF = 43
VTK_PARSER_IHAT = 40
VTK_PARSER_IMMEDIATE = 1
VTK_PARSER_JHAT = 41
VTK_PARSER_KHAT = 42
VTK_PARSER_LESS_THAN = 45
VTK_PARSER_LOGARITHM = 13
VTK_PARSER_LOGARITHM10 = 15
VTK_PARSER_LOGARITHME = 14
VTK_PARSER_MAGNITUDE = 38
VTK_PARSER_MAX = 27
VTK_PARSER_MIN = 26
VTK_PARSER_MULTIPLY = 6
VTK_PARSER_NORMALIZE = 39
VTK_PARSER_OR = 49
VTK_PARSER_POWER = 8
VTK_PARSER_SCALAR_TIMES_VECTOR = 35
VTK_PARSER_SIGN = 29
VTK_PARSER_SINE = 17
VTK_PARSER_SQUARE_ROOT = 16
VTK_PARSER_SUBTRACT = 5
VTK_PARSER_TANGENT = 19
VTK_PARSER_UNARY_MINUS = 2
VTK_PARSER_UNARY_PLUS = 3
VTK_PARSER_VECTOR_ADD = 33
VTK_PARSER_VECTOR_IF = 44
VTK_PARSER_VECTOR_OVER_SCALAR = 37
VTK_PARSER_VECTOR_SUBTRACT = 34
VTK_PARSER_VECTOR_TIMES_SCALAR = 36
VTK_PARSER_VECTOR_UNARY_MINUS = 30
VTK_PARSER_VECTOR_UNARY_PLUS = 31
VTK_PARTIAL_OVERLAP = 3
VTK_PARTITIONED_DATA_SET = 37
VTK_PARTITIONED_DATA_SET_COLLECTION = 38
VTK_PATH = 35
VTK_PBR = 3
VTK_PENTAGONAL_PRISM = 15
VTK_PERIODIC_ARRAY_AXIS_X = 0
VTK_PERIODIC_ARRAY_AXIS_Y = 1
VTK_PERIODIC_ARRAY_AXIS_Z = 2
VTK_PERIODIC_DATA_ARRAY = 9
VTK_PHONG = 2
VTK_PIECES_EXTENT = 0
VTK_PIECEWISE_FUNCTION = 5
VTK_PISTON_DATA_OBJECT = 34
VTK_PIXEL = 8
VTK_PLANE_OFF = 0
VTK_PLANE_OUTLINE = 1
VTK_PLANE_SURFACE = 3
VTK_PLANE_WIREFRAME = 2
VTK_PLOT_FIELD_DATA = 6
VTK_PLOT_NORMALS = 3
VTK_PLOT_SCALARS = 1
VTK_PLOT_TCOORDS = 4
VTK_PLOT_TENSORS = 5
VTK_PLOT_VECTORS = 2
VTK_POINTS = 0
VTK_POINT_DATA = 1
VTK_POINT_DATA_FIELD = 1
VTK_POINT_EXPONENTIAL = 2
VTK_POINT_EXTRUSION = 3
VTK_POINT_SET = 9
VTK_POINT_SHELL = 0
VTK_POINT_UNIFORM = 1
VTK_POLYGON = 7
VTK_POLYHEDRON = 42
VTK_POLY_DATA = 0
VTK_POLY_LINE = 4
VTK_POLY_VERTEX = 2
VTK_POSE = 5
VTK_PROJECTED_TEXTURE_USE_PINHOLE = 0
VTK_PROJECTED_TEXTURE_USE_TWO_MIRRORS = 1
VTK_PROJECTION_OBLIQUE = 3
VTK_PROJECTION_XY = 2
VTK_PROJECTION_XZ = 1
VTK_PROJECTION_YZ = 0
VTK_PYRAMID = 14
VTK_QUAD = 9
VTK_QUADRATIC_EDGE = 21
VTK_QUADRATIC_HEXAHEDRON = 25
VTK_QUADRATIC_LINEAR_QUAD = 30
VTK_QUADRATIC_LINEAR_WEDGE = 31
VTK_QUADRATIC_POLYGON = 36
VTK_QUADRATIC_PYRAMID = 27
VTK_QUADRATIC_QUAD = 23
VTK_QUADRATIC_TETRA = 24
VTK_QUADRATIC_TRIANGLE = 22
VTK_QUADRATIC_WEDGE = 26
VTK_RAMP_LINEAR = 0
VTK_RAMP_SCURVE = 1
VTK_RAMP_SQRT = 2
VTK_RBF_CUSTOM = 0
VTK_RBF_R = 1
VTK_RBF_R2LOGR = 2
VTK_RECTILINEAR_GRID = 3
VTK_REEB_GRAPH = 28
VTK_REPLACECBYK = 20
VTK_RESLICE_CUBIC = 2
VTK_RESLICE_CURSOR_REPRESENTATION_MAX_TEXTBUFF = 128
VTK_RESLICE_LINEAR = 1
VTK_RESLICE_NEAREST = 0
VTK_RESOLVE_OFF = 0
VTK_RESOLVE_POLYGON_OFFSET = 1
VTK_RESOLVE_SHIFT_ZBUFFER = 2
VTK_RGB = 3
VTK_RGBA = 4
VTK_ROTATION_MODE_ARRAY_VALUE = 1
VTK_ROTATION_MODE_DIRECT_ANGLE = 0
VTK_RULED_MODE_POINT_WALK = 1
VTK_RULED_MODE_RESAMPLE = 0
VTK_SCALAR_MODE_DEFAULT = 0
VTK_SCALAR_MODE_INDEX = 0
VTK_SCALAR_MODE_USE_CELL_DATA = 2
VTK_SCALAR_MODE_USE_CELL_FIELD_DATA = 4
VTK_SCALAR_MODE_USE_FIELD_DATA = 5
VTK_SCALAR_MODE_USE_POINT_DATA = 1
VTK_SCALAR_MODE_USE_POINT_FIELD_DATA = 3
VTK_SCALAR_MODE_VALUE = 1
VTK_SCALED_SOA_DATA_ARRAY = 7
VTK_SCALE_BY_SCALAR = 0
VTK_SCALE_BY_VECTOR = 1
VTK_SCALE_BY_VECTORCOMPONENTS = 2
VTK_SCALE_LINEAR = 0
VTK_SCALE_LOG10 = 1
VTK_SELECTION = 22
VTK_SET_TRANSFORM_PLANE = 1
VTK_SHORT = 4
VTK_SHORT_MAX = 32767
VTK_SHORT_MIN = -32768
VTK_SIGNED_CHAR = 15
VTK_SIGNED_CHAR_MAX = 127
VTK_SIGNED_CHAR_MIN = -128
VTK_SIN = 5
VTK_SINC_KERNEL_SIZE_MAX = 32
VTK_SINGLE_POINT = 1
VTK_SIZEOF_CHAR = 1
VTK_SIZEOF_DOUBLE = 8
VTK_SIZEOF_FLOAT = 4
VTK_SIZEOF_ID_TYPE = 8
VTK_SIZEOF_INT = 4
VTK_SIZEOF_LONG = 4
VTK_SIZEOF_LONG_LONG = 8
VTK_SIZEOF_SHORT = 2
VTK_SIZEOF_VOID_P = 8
VTK_SKIP_RETURN_CODE = 125
VTK_SMP_BACKEND = 'Sequential'
VTK_SMP_DEFAULT_IMPLEMENTATION_OPENMP = 0
VTK_SMP_DEFAULT_IMPLEMENTATION_SEQUENTIAL = 1
VTK_SMP_DEFAULT_IMPLEMENTATION_STDTHREAD = 0
VTK_SMP_DEFAULT_IMPLEMENTATION_TBB = 0
VTK_SMP_ENABLE_OPENMP = 0
VTK_SMP_ENABLE_SEQUENTIAL = 1
VTK_SMP_ENABLE_STDTHREAD = 1
VTK_SMP_ENABLE_TBB = 0
VTK_SOA_DATA_ARRAY = 6
VTK_SOLID_CUBE = 1
VTK_SOLID_DODECAHEDRON = 4
VTK_SOLID_ICOSAHEDRON = 3
VTK_SOLID_OCTAHEDRON = 2
VTK_SOLID_TETRAHEDRON = 0
VTK_SORT_BY_CELL = 1
VTK_SORT_BY_VALUE = 0
VTK_SOURCE_VERSION = 'vtk version 9.6.2'
VTK_SPHERE_OFF = 0
VTK_SPHERE_SURFACE = 2
VTK_SPHERE_TREE_LEVELS = 0
VTK_SPHERE_TREE_LINE = 2
VTK_SPHERE_TREE_PLANE = 3
VTK_SPHERE_TREE_POINT = 1
VTK_SPHERE_WIREFRAME = 1
VTK_SQL_ALLBACKENDS = '*'
VTK_SQL_DEFAULT_COLUMN_SIZE = 32
VTK_SQL_FEATURE_BATCH_OPERATIONS = 1008
VTK_SQL_FEATURE_BLOB = 1002
VTK_SQL_FEATURE_LAST_INSERT_ID = 1007
VTK_SQL_FEATURE_NAMED_PLACEHOLDERS = 1005
VTK_SQL_FEATURE_POSITIONAL_PLACEHOLDERS = 1006
VTK_SQL_FEATURE_PREPARED_QUERIES = 1004
VTK_SQL_FEATURE_QUERY_SIZE = 1001
VTK_SQL_FEATURE_TRANSACTIONS = 1000
VTK_SQL_FEATURE_TRIGGERS = 1009
VTK_SQL_FEATURE_UNICODE = 1003
VTK_SQL_MYSQL = 'vtkMySQLDatabase'
VTK_SQL_POSTGRESQL = 'vtkPostgreSQLDatabase'
VTK_SQL_SQLITE = 'vtkSQLiteDatabase'
VTK_SQR = 10
VTK_SQRT = 11
VTK_SQUARE_GLYPH = 6
VTK_STATISTICAL_MODEL = 52
VTK_STD_FUNCTION_ARRAY = 15
VTK_STEREO_ANAGLYPH = 7
VTK_STEREO_CHECKERBOARD = 8
VTK_STEREO_CRYSTAL_EYES = 1
VTK_STEREO_DRESDEN = 6
VTK_STEREO_EMULATE = 11
VTK_STEREO_FAKE = 10
VTK_STEREO_INTERLACED = 3
VTK_STEREO_LEFT = 4
VTK_STEREO_RED_BLUE = 2
VTK_STEREO_RIGHT = 5
VTK_STEREO_SPLITVIEWPORT_HORIZONTAL = 9
VTK_STEREO_ZSPACE_INSPIRE = 12
VTK_STRIDED_ARRAY = 16
VTK_STRING = 13
VTK_STRING_ARRAY = 2
VTK_STRUCTURED_GRID = 2
VTK_STRUCTURED_POINTS = 1
VTK_STRUCTURED_POINT_ARRAY = 17
VTK_STYLE_PIXELIZE = 0
VTK_STYLE_POLYGONALIZE = 1
VTK_STYLE_RUN_LENGTH = 2
VTK_SUBDIVIDE_LENGTH = 1
VTK_SUBDIVIDE_SPECIFIED = 0
VTK_SUBTRACT = 1
VTK_SURFACE = 2
VTK_TABLE = 19
VTK_TCOORDS_FROM_LENGTH = 2
VTK_TCOORDS_FROM_NORMALIZED_LENGTH = 1
VTK_TCOORDS_FROM_SCALARS = 3
VTK_TCOORDS_OFF = 0
VTK_TEMPORAL_DATA_SET = 18
VTK_TENSOR_MODE_COMPUTE_GRADIENT = 1
VTK_TENSOR_MODE_COMPUTE_GREEN_LAGRANGE_STRAIN = 3
VTK_TENSOR_MODE_COMPUTE_STRAIN = 2
VTK_TENSOR_MODE_PASS_TENSORS = 0
VTK_TETRA = 10
VTK_TEXTURECOORDS_TEXTUREUV = 1
VTK_TEXTURECOORDS_UV = 0
VTK_TEXTURE_QUALITY_16BIT = 16
VTK_TEXTURE_QUALITY_32BIT = 32
VTK_TEXTURE_QUALITY_DEFAULT = 0
VTK_TEXTURE_STYLE_FIT_IMAGE = 0
VTK_TEXTURE_STYLE_PROPORTIONAL = 1
VTK_TEXT_BOTTOM = 0
VTK_TEXT_CENTERED = 1
VTK_TEXT_GLOBAL_ANTIALIASING_ALL = 2
VTK_TEXT_GLOBAL_ANTIALIASING_NONE = 1
VTK_TEXT_GLOBAL_ANTIALIASING_SOME = 0
VTK_TEXT_LEFT = 0
VTK_TEXT_RIGHT = 2
VTK_TEXT_TOP = 2
VTK_THICKARROW_GLYPH = 10
VTK_THICKCROSS_GLYPH = 4
VTK_THREAD_RETURN_VALUE = 0
VTK_TIMES = 2
VTK_TIME_EXTENT = 2
VTK_TOL = 1e-05
VTK_TREE = 21
VTK_TRIANGLE = 5
VTK_TRIANGLE_GLYPH = 5
VTK_TRIANGLE_STRIP = 6
VTK_TRIQUADRATIC_HEXAHEDRON = 29
VTK_TRIQUADRATIC_PYRAMID = 37
VTK_TYPE_CHAR_IS_SIGNED = 1
VTK_TYPE_FLOAT32 = 10
VTK_TYPE_FLOAT64 = 11
VTK_TYPE_INT16 = 4
VTK_TYPE_INT16_MAX = 32767
VTK_TYPE_INT16_MIN = -32768
VTK_TYPE_INT32 = 6
VTK_TYPE_INT32_MAX = 2147483647
VTK_TYPE_INT32_MIN = -2147483648
VTK_TYPE_INT64 = 16
VTK_TYPE_INT64_MAX = 9223372036854775807
VTK_TYPE_INT64_MIN = -9223372036854775808
VTK_TYPE_INT8 = 15
VTK_TYPE_INT8_MAX = 127
VTK_TYPE_INT8_MIN = -128
VTK_TYPE_LONG_LONG_FORMAT = '%ll'
VTK_TYPE_UINT16 = 5
VTK_TYPE_UINT16_MAX = 65535
VTK_TYPE_UINT16_MIN = 0
VTK_TYPE_UINT32 = 7
VTK_TYPE_UINT32_MAX = 4294967295
VTK_TYPE_UINT32_MIN = 0
VTK_TYPE_UINT64 = 17
VTK_TYPE_UINT64_MAX = 18446744073709551615
VTK_TYPE_UINT64_MIN = 0
VTK_TYPE_UINT8 = 3
VTK_TYPE_UINT8_MAX = 255
VTK_TYPE_UINT8_MIN = 0
VTK_UNCHANGED = 0
VTK_UNDIRECTED_GRAPH = 24
VTK_UNIFORM_GRID = 10
VTK_UNIFORM_GRID_AMR = 29
VTK_UNIFORM_HYPER_TREE_GRID = 39
VTK_UNKNOWN_FONT = 3
VTK_UNSIGNED_CHAR = 3
VTK_UNSIGNED_CHAR_MAX = 255
VTK_UNSIGNED_CHAR_MIN = 0
VTK_UNSIGNED_INT = 7
VTK_UNSIGNED_INT_MAX = 4294967295
VTK_UNSIGNED_INT_MIN = 0
VTK_UNSIGNED_LONG = 9
VTK_UNSIGNED_LONG_LONG = 17
VTK_UNSIGNED_LONG_LONG_MAX = 18446744073709551615
VTK_UNSIGNED_LONG_LONG_MIN = 0
VTK_UNSIGNED_LONG_MAX = 4294967295
VTK_UNSIGNED_LONG_MIN = 0
VTK_UNSIGNED_SHORT = 5
VTK_UNSIGNED_SHORT_MAX = 65535
VTK_UNSIGNED_SHORT_MIN = 0
VTK_UNSTRUCTURED_GRID = 4
VTK_UNSTRUCTURED_GRID_BASE = 36
VTK_UPDATE_EXTENT_COMBINE = 1
VTK_UPDATE_EXTENT_REPLACE = 2
VTK_USERDEFINED = 7
VTK_USE_FLOAT32 = 1
VTK_USE_FLOAT64 = 1
VTK_USE_FUTURE_BOOL = 0
VTK_USE_FUTURE_CONST = 0
VTK_USE_INT16 = 1
VTK_USE_INT32 = 1
VTK_USE_INT64 = 1
VTK_USE_INT8 = 1
VTK_USE_NORMAL = 1
VTK_USE_UINT16 = 1
VTK_USE_UINT32 = 1
VTK_USE_UINT64 = 1
VTK_USE_UINT8 = 1
VTK_USE_VECTOR = 0
VTK_VARIANT = 20
VTK_VARIANT_ARRAY = 3
VTK_VARY_RADIUS_BY_ABSOLUTE_SCALAR = 3
VTK_VARY_RADIUS_BY_SCALAR = 1
VTK_VARY_RADIUS_BY_VECTOR = 2
VTK_VARY_RADIUS_BY_VECTOR_NORM = 4
VTK_VARY_RADIUS_OFF = 0
VTK_VECTOR_EXTRUSION = 1
VTK_VECTOR_MODE_COMPUTE_GRADIENT = 1
VTK_VECTOR_MODE_COMPUTE_VORTICITY = 2
VTK_VECTOR_MODE_PASS_VECTORS = 0
VTK_VECTOR_ROTATION_OFF = 2
VTK_VERSION = '9.6.2'
VTK_VERSION_FULL = '9.6.2'
VTK_VERSION_NUMBER = 90600000002
VTK_VERSION_NUMBER_QUICK = 90600000002
VTK_VERTEX = 1
VTK_VERTEX_GLYPH = 1
VTK_VIEW = 4
VTK_VIEWPORT = 2
VTK_VOID = 0
VTK_VOXEL = 11
VTK_VOXEL_MODE = 0
VTK_VOXEL_TO_12_TET = 12
VTK_VOXEL_TO_5_AND_12_TET = -1
VTK_VOXEL_TO_5_TET = 5
VTK_VOXEL_TO_6_TET = 6
VTK_WEDGE = 13
VTK_WIPE_HORIZONTAL = 1
VTK_WIPE_LOWER_LEFT = 3
VTK_WIPE_LOWER_RIGHT = 4
VTK_WIPE_QUAD = 0
VTK_WIPE_UPPER_LEFT = 5
VTK_WIPE_UPPER_RIGHT = 6
VTK_WIPE_VERTICAL = 2
VTK_WIREFRAME = 1
VTK_WORLD = 6
VTK_XOR = 2
VTK_XYPLOT_ARC_LENGTH = 1
VTK_XYPLOT_COLUMN = 1
VTK_XYPLOT_INDEX = 0
VTK_XYPLOT_NORMALIZED_ARC_LENGTH = 2
VTK_XYPLOT_ROW = 0
VTK_XYPLOT_VALUE = 3
VTK_XYPLOT_Y_AXIS_HCENTER = 1
VTK_XYPLOT_Y_AXIS_TOP = 0
VTK_XYPLOT_Y_AXIS_VCENTER = 2
VTK_XYZ_GRID = 8
VTK_XY_PLANE = 5
VTK_XZ_PLANE = 7
VTK_X_LINE = 2
VTK_YZ_PLANE = 6
VTK_Y_LINE = 3
VTK_ZBUFFER = 5
VTK_Z_LINE = 4
vtkBoundaryCentered = 2
vtkCellCentered = 1
vtkEventDataNumberOfDevices = 5
vtkEventDataNumberOfInputs = 6
vtkMaxPythagoreanQuadrupleId = 12341
vtkPointCentered = 0
wLINES = 1
wPOINTS = 0
wTRIANGLES = 2
VERSION
9.6.2
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\vtk.py
pyvista.PLOT_DIRECTIVE_THEME
Python Library Documentation: NoneType object class NoneType(object) | Methods defined here: | | __bool__(self, /) | True if self else False | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) | Create and return a new object. See help(type) for accurate signature.
pyvista.PLYReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.PLYWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.PNGReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.PNGWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.PNMReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.PNMWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.POpenFOAMReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.PTSReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.PVDDataSet
Python Library Documentation: class PVDDataSet in module pyvista.core.utilities.reader
class PVDDataSet(pyvista.core.utilities.misc._NoNewAttrMixin)
| PVDDataSet(*args, **kwargs) -> '_T'
|
| Class for storing dataset info from PVD file.
|
| Method resolution order:
| PVDDataSet
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, time: 'float', part: 'int', path: 'str', group: 'str') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __repr__(self)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'group': 'str', 'part': 'int', 'path': 'str', 'time...
|
| __dataclass_fields__ = {'group': Field(name='group',type='str',default...
|
| __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
|
| __hash__ = None
|
| __match_args__ = ('time', 'part', 'path', 'group')
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
pyvista.PVDReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.ParametricBohemianDome
Python Library Documentation: function ParametricBohemianDome in module pyvista.core.utilities.parametric_objects
ParametricBohemianDome(a: 'float | None' = None, b: 'float | None' = None, c: 'float | None' = None, **kwargs) -> 'PolyData'
Generate a Bohemian dome surface.
Parameters
----------
a : float, default: 0.5
Bohemian dome surface parameter a.
b : float, default: 1.5
Bohemian dome surface parameter b.
c : float, default: 1.0
Bohemian dome surface parameter c.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricBohemianDome surface.
Examples
--------
Create a ParametricBohemianDome mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricBohemianDome()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricBour
Python Library Documentation: function ParametricBour in module pyvista.core.utilities.parametric_objects
ParametricBour(**kwargs) -> 'PolyData'
Generate Bour's minimal surface.
Parameters
----------
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricBour surface.
Examples
--------
Create a ParametricBour mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricBour()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricBoy
Python Library Documentation: function ParametricBoy in module pyvista.core.utilities.parametric_objects
ParametricBoy(zscale: 'float | None' = None, **kwargs) -> 'PolyData'
Generate Boy's surface.
This is a model of the projective plane without singularities. It
was found by Werner Boy on assignment from David Hilbert.
For further information about this surface, please consult the
technical description "Parametric surfaces" in the
"VTK Technical Documents" section in the VTK.org web pages.
Parameters
----------
zscale : float, optional
The scale factor for the z-coordinate.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricBoy surface.
Examples
--------
Create a ParametricBoy mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricBoy()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricCatalanMinimal
Python Library Documentation: function ParametricCatalanMinimal in module pyvista.core.utilities.parametric_objects
ParametricCatalanMinimal(**kwargs) -> 'PolyData'
Generate Catalan's minimal surface.
ParametricCatalanMinimal generates Catalan's minimal surface
parametrically. This minimal surface contains the cycloid as a
geodesic.
Parameters
----------
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricCatalanMinimal surface.
Examples
--------
Create a ParametricCatalanMinimal mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricCatalanMinimal()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricConicSpiral
Python Library Documentation: function ParametricConicSpiral in module pyvista.core.utilities.parametric_objects
ParametricConicSpiral(a: 'float | None' = None, b: 'float | None' = None, c: 'float | None' = None, n: 'float | None' = None, **kwargs) -> 'PolyData'
Generate conic spiral surfaces that resemble sea-shells.
ParametricConicSpiral generates conic spiral surfaces. These can
resemble sea shells, or may look like a torus "eating" its own
tail.
Parameters
----------
a : float, default: 0.2
The scale factor.
b : float, default: 1
The A function coefficient.
See the definition in Parametric surfaces referred to above.
c : float, default: 0.1
The B function coefficient.
See the definition in Parametric surfaces referred to above.
n : float, default: 2
The C function coefficient.
See the definition in Parametric surfaces referred to above.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricConicSpiral surface.
Examples
--------
Create a ParametricConicSpiral mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricConicSpiral()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricCrossCap
Python Library Documentation: function ParametricCrossCap in module pyvista.core.utilities.parametric_objects
ParametricCrossCap(**kwargs) -> 'PolyData'
Generate a cross-cap.
ParametricCrossCap generates a cross-cap which is a non-orientable
self-intersecting single-sided surface. This is one possible
image of a projective plane in three-space.
Parameters
----------
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricCrossCap surface.
Examples
--------
Create a ParametricCrossCap mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricCrossCap()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricDini
Python Library Documentation: function ParametricDini in module pyvista.core.utilities.parametric_objects
ParametricDini(a: 'float | None' = None, b: 'float | None' = None, **kwargs) -> 'PolyData'
Generate Dini's surface.
ParametricDini generates Dini's surface. Dini's surface is a
surface that possesses constant negative Gaussian curvature
Parameters
----------
a : float, default: 1.0
The scale factor. See the definition in Parametric surfaces
referred to above.
b : float, default: 0.2
The scale factor. See the definition in Parametric surfaces
referred to above.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricDini surface.
Examples
--------
Create a ParametricDini mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricDini()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricEllipsoid
Python Library Documentation: function ParametricEllipsoid in module pyvista.core.utilities.parametric_objects
ParametricEllipsoid(xradius: 'float | None' = None, yradius: 'float | None' = None, zradius: 'float | None' = None, **kwargs) -> 'PolyData'
Generate an ellipsoid.
ParametricEllipsoid generates an ellipsoid. If all the radii are
the same, we have a sphere. An oblate spheroid occurs if RadiusX
= RadiusY > RadiusZ. Here the Z-axis forms the symmetry axis. To
a first approximation, this is the shape of the earth. A prolate
spheroid occurs if RadiusX = RadiusY < RadiusZ.
Parameters
----------
xradius : float, default: 1.0
The scaling factor for the x-axis.
yradius : float, default: 1.0
The scaling factor for the y-axis.
zradius : float, default: 1.0
The scaling factor for the z-axis.
**kwargs : dict, optional
See :func:`surface_from_para` and :func:`parametric_keywords`
for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricEllipsoid surface.
Examples
--------
Create a ParametricEllipsoid mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricEllipsoid()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricEnneper
Python Library Documentation: function ParametricEnneper in module pyvista.core.utilities.parametric_objects
ParametricEnneper(**kwargs) -> 'PolyData'
Generate Enneper's surface.
ParametricEnneper generates Enneper's surface. Enneper's surface
is a self-intersecting minimal surface possessing constant
negative Gaussian curvature.
Parameters
----------
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricEnneper surface.
Examples
--------
Create a ParametricEnneper mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricEnneper()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricFigure8Klein
Python Library Documentation: function ParametricFigure8Klein in module pyvista.core.utilities.parametric_objects
ParametricFigure8Klein(radius: 'float | None' = None, **kwargs) -> 'PolyData'
Generate a figure-8 Klein bottle.
ParametricFigure8Klein generates a figure-8 Klein bottle. A Klein
bottle is a closed surface with no interior and only one surface.
It is unrealisable in 3 dimensions without intersecting surfaces.
Parameters
----------
radius : float, default: 1.0
The radius of the bottle.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricFigure8Klein surface.
Examples
--------
Create a ParametricFigure8Klein mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricFigure8Klein()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricHenneberg
Python Library Documentation: function ParametricHenneberg in module pyvista.core.utilities.parametric_objects
ParametricHenneberg(**kwargs) -> 'PolyData'
Generate Henneberg's minimal surface.
Parameters
----------
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricHenneberg surface.
Examples
--------
Create a ParametricHenneberg mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricHenneberg()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricKlein
Python Library Documentation: function ParametricKlein in module pyvista.core.utilities.parametric_objects
ParametricKlein(**kwargs) -> 'PolyData'
Generate a "classical" representation of a Klein bottle.
ParametricKlein generates a "classical" representation of a Klein
bottle. A Klein bottle is a closed surface with no interior and only one
surface. It is unrealisable in 3 dimensions without intersecting
surfaces.
Parameters
----------
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricKlein surface.
Examples
--------
Create a ParametricKlein mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricKlein()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricKuen
Python Library Documentation: function ParametricKuen in module pyvista.core.utilities.parametric_objects
ParametricKuen(deltav0: 'float | None' = None, **kwargs) -> 'PolyData'
Generate Kuens' surface.
ParametricKuen generates Kuens' surface. This surface has a constant
negative Gaussian curvature.
Parameters
----------
deltav0 : float, default: 0.05
The value to use when ``V == 0``.
This has the best appearance with the default settings.
Setting it to a value less than 0.05 extrapolates the surface
towards a pole in the -z direction.
Setting it to 0 retains the pole whose z-value is -inf.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricKuen surface.
Examples
--------
Create a ParametricKuen mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricKuen()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricMobius
Python Library Documentation: function ParametricMobius in module pyvista.core.utilities.parametric_objects
ParametricMobius(radius: 'float | None' = None, **kwargs) -> 'PolyData'
Generate a Mobius strip.
Parameters
----------
radius : float, default: 1.0
The radius of the Mobius strip.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricMobius surface.
Examples
--------
Create a ParametricMobius mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricMobius()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricPluckerConoid
Python Library Documentation: function ParametricPluckerConoid in module pyvista.core.utilities.parametric_objects
ParametricPluckerConoid(n: 'int | None' = None, **kwargs) -> 'PolyData'
Generate Plucker's conoid surface.
ParametricPluckerConoid generates Plucker's conoid surface
parametrically. Plucker's conoid is a ruled surface, named after
Julius Plucker. It is possible to set the number of folds in this
class via the parameter 'n'.
Parameters
----------
n : int, optional
This is the number of folds in the conoid.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricPluckerConoid surface.
Examples
--------
Create a ParametricPluckerConoid mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricPluckerConoid()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricPseudosphere
Python Library Documentation: function ParametricPseudosphere in module pyvista.core.utilities.parametric_objects
ParametricPseudosphere(**kwargs) -> 'PolyData'
Generate a pseudosphere.
ParametricPseudosphere generates a parametric pseudosphere. The
pseudosphere is generated as a surface of revolution of the
tractrix about it's asymptote, and is a surface of constant
negative Gaussian curvature.
Parameters
----------
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricPseudosphere surface.
Examples
--------
Create a ParametricPseudosphere mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricPseudosphere()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricRandomHills
Python Library Documentation: function ParametricRandomHills in module pyvista.core.utilities.parametric_objects
ParametricRandomHills(number_of_hills: 'int | None' = None, hill_x_variance: 'float | None' = None, hill_y_variance: 'float | None' = None, hill_amplitude: 'float | None' = None, random_seed: 'int | None' = None, x_variance_scale_factor: 'float | None' = None, y_variance_scale_factor: 'float | None' = None, amplitude_scale_factor: 'float | None' = None, **kwargs) -> 'PolyData'
Generate a surface covered with randomly placed hills.
ParametricRandomHills generates a surface covered with randomly
placed hills. Hills will vary in shape and height since the
presence of nearby hills will contribute to the shape and height
of a given hill. An option is provided for placing hills on a
regular grid on the surface. In this case the hills will all have
the same shape and height.
Parameters
----------
number_of_hills : int, default: 30
The number of hills.
hill_x_variance : float, default: 2.5
The hill variance in the x-direction.
hill_y_variance : float, default: 2.5
The hill variance in the y-direction.
hill_amplitude : float, default: 2
The hill amplitude (height).
random_seed : int, default: 1
The Seed for the random number generator,
a value of 1 will initialize the random number generator,
a negative value will initialize it with the system time.
x_variance_scale_factor : float, default: 13
The scaling factor for the variance in the x-direction.
y_variance_scale_factor : float, default: 13
The scaling factor for the variance in the y-direction.
amplitude_scale_factor : float, default: 13
The scaling factor for the amplitude.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricRandomHills surface.
Examples
--------
Create a ParametricRandomHills mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricRandomHills()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricRoman
Python Library Documentation: function ParametricRoman in module pyvista.core.utilities.parametric_objects
ParametricRoman(radius: 'float | None' = None, **kwargs) -> 'PolyData'
Generate Steiner's Roman Surface.
Parameters
----------
radius : float, default: 1
The radius.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricRoman surface.
Examples
--------
Create a ParametricRoman mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricRoman()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricSuperEllipsoid
Python Library Documentation: function ParametricSuperEllipsoid in module pyvista.core.utilities.parametric_objects
ParametricSuperEllipsoid(xradius: 'float | None' = None, yradius: 'float | None' = None, zradius: 'float | None' = None, n1: 'float | None' = None, n2: 'float | None' = None, **kwargs) -> 'PolyData'
Generate a superellipsoid.
ParametricSuperEllipsoid generates a superellipsoid. A superellipsoid
is a versatile primitive that is controlled by two parameters n1 and
n2. As special cases it can represent a sphere, square box, and closed
cylindrical can.
Parameters
----------
xradius : float, default: 1
The scaling factor for the x-axis.
yradius : float, default: 1
The scaling factor for the y-axis.
zradius : float, default: 1
The scaling factor for the z-axis.
n1 : float, default: 1
The "squareness" parameter in the z-axis.
n2 : float, default: 1
The "squareness" parameter in the x-y plane.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricSuperEllipsoid surface.
See Also
--------
pyvista.ParametricSuperToroid :
Toroidal equivalent of ParametricSuperEllipsoid.
pyvista.Superquadric :
Geometric object with additional parameters.
Examples
--------
Create a ParametricSuperEllipsoid surface that looks like a box
with smooth edges.
>>> import pyvista as pv
>>> mesh = pv.ParametricSuperEllipsoid(n1=0.02, n2=0.02)
>>> mesh.plot(color='w', smooth_shading=True)
Create one that looks like a spinning top.
>>> mesh = pv.ParametricSuperEllipsoid(n1=4, n2=0.5)
>>> mesh.plot(color='w', smooth_shading=True, cpos='xz')
pyvista.ParametricSuperToroid
Python Library Documentation: function ParametricSuperToroid in module pyvista.core.utilities.parametric_objects
ParametricSuperToroid(ringradius: 'float | None' = None, crosssectionradius: 'float | None' = None, xradius: 'float | None' = None, yradius: 'float | None' = None, zradius: 'float | None' = None, n1: 'float | None' = None, n2: 'float | None' = None, **kwargs) -> 'PolyData'
Generate a supertoroid.
ParametricSuperToroid generates a supertoroid. Essentially a
supertoroid is a torus with the sine and cosine terms raised to a power.
A supertoroid is a versatile primitive that is controlled by four
parameters r0, r1, n1 and n2. r0, r1 determine the type of torus whilst
the value of n1 determines the shape of the torus ring and n2 determines
the shape of the cross section of the ring. It is the different values of
these powers which give rise to a family of 3D shapes that are all
basically toroidal in shape.
Parameters
----------
ringradius : float, default: 1
The radius from the center to the middle of the ring of the
supertoroid.
crosssectionradius : float, default: 0.5
The radius of the cross section of ring of the supertoroid.
xradius : float, default: 1
The scaling factor for the x-axis.
yradius : float, default: 1
The scaling factor for the y-axis.
zradius : float, default: 1
The scaling factor for the z-axis.
n1 : float, default: 1
The shape of the torus ring.
n2 : float, default: 1
The shape of the cross section of the ring.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricSuperToroid surface.
See Also
--------
pyvista.ParametricSuperEllipsoid :
Ellipsoidal equivalent of ParametricSuperToroid.
pyvista.Superquadric :
Geometric object with additional parameters.
Examples
--------
Create a ParametricSuperToroid mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricSuperToroid(n1=2, n2=0.3)
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParametricTorus
Python Library Documentation: function ParametricTorus in module pyvista.core.utilities.parametric_objects
ParametricTorus(ringradius: 'float | None' = None, crosssectionradius: 'float | None' = None, **kwargs) -> 'PolyData'
Generate a torus.
Parameters
----------
ringradius : float, default: 1.0
The radius from the center to the middle of the ring of the
torus.
crosssectionradius : float, default: 0.5
The radius of the cross section of ring of the torus.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricTorus surface.
Examples
--------
Create a ParametricTorus mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricTorus()
>>> mesh.plot(color='w', smooth_shading=True)
pyvista.ParticleReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.PartitionedDataSet
Python Library Documentation: class PartitionedDataSet in module pyvista.core.partitioned
class PartitionedDataSet(pyvista.core.dataobject.DataObject, collections.abc.MutableSequence, vtkmodules.vtkCommonDataModel.vtkPartitionedDataSet)
| PartitionedDataSet(*args, **kwargs) -> '_T'
|
| Wrapper for the :vtk:`vtkPartitionedDataSet` class.
|
| DataSet which composite dataset to encapsulates a dataset consisting of partitions.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> partitions = pv.PartitionedDataSet(data)
| >>> len(partitions)
| 3
|
| Method resolution order:
| PartitionedDataSet
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| collections.abc.MutableSequence
| collections.abc.Sequence
| collections.abc.Reversible
| collections.abc.Collection
| collections.abc.Sized
| collections.abc.Iterable
| collections.abc.Container
| vtkmodules.vtkCommonDataModel.vtkPartitionedDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObjectTree
| vtkmodules.vtkCommonDataModel.vtkCompositeDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __delitem__(self, index: 'int | slice') -> 'None'
| Remove a partition at the specified index are not supported.
|
| __getitem__(self, index)
| Get a partition by its index.
|
| __init__(self, *args, **kwargs)
| Initialize the PartitionedDataSet.
|
| __len__(self) -> 'int'
| Return the number of partitions.
|
| __repr__(self) -> 'str'
| Define an adequate representation.
|
| __setitem__(self, index: 'int | slice', data)
| Set a partition with a VTK data object.
|
| __str__(self) -> 'str'
| Return the str representation of the multi partition.
|
| append(self, dataset) -> 'None'
| Add a data set to the next partition index.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to append to this partitioned dataset.
|
| copy(self, deep: 'bool' = True)
| Return a copy of the PartitionedDataSet.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True``, make a full copy of the object.
|
| Returns
| -------
| pyvista.PartitionedDataSet
| Deep or shallow copy of the ``PartitionedDataSet``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> partitions = pv.PartitionedDataSet(data)
| >>> new_partitions = partitions.copy()
| >>> len(new_partitions)
| 3
|
| copy_meta_from(self, ido, deep) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| get_data_range(self: 'Self', name: 'str | None', preference: 'FieldAssociation | str') -> 'tuple[float, float]'
| Get the non-NaN min and max of a named array.
|
| insert(self, index: 'int', dataset: 'DataSet') -> 'None'
| Insert data before index.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| pop(self, index: 'int' = -1) -> 'None'
| Pop off a partition at the specified index are not supported.
|
| wrap_nested(self) -> 'None'
| Ensure that all nested data structures are wrapped as PyVista datasets.
|
| This is performed in place.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| is_empty
| Return ``True`` if there are no partitions.
|
| .. versionadded:: 0.46
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PartitionedDataSet()
| >>> mesh.is_empty
| True
|
| >>> mesh.append(pv.Sphere())
| >>> mesh.is_empty
| False
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| n_partitions
| Return the number of partitions.
|
| Returns
| -------
| int
| The number of partitions.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from collections.abc.MutableSequence:
|
| __iadd__(self, values)
|
| clear(self)
| S.clear() -> None -- remove all items from S
|
| extend(self, values)
| S.extend(iterable) -- extend sequence by appending elements from the iterable
|
| remove(self, value)
| S.remove(value) -- remove first occurrence of value.
| Raise ValueError if the value is not present.
|
| reverse(self)
| S.reverse() -- reverse *IN PLACE*
|
| ----------------------------------------------------------------------
| Methods inherited from collections.abc.Sequence:
|
| __contains__(self, value)
|
| __iter__(self)
|
| __reversed__(self)
|
| count(self, value)
| S.count(value) -> integer -- return number of occurrences of value
|
| index(self, value, start=0, stop=None)
| S.index(value, [start, [stop]]) -> integer -- return first index of value.
| Raises ValueError if the value is not present.
|
| Supporting start and stop arguments is optional, but
| recommended.
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.abc.Reversible:
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.abc.Iterable:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkPartitionedDataSet:
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkPartitionedDataSet
| C++: static vtkPartitionedDataSet *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkPartitionedDataSet
| C++: static vtkPartitionedDataSet *GetData(
| vtkInformationVector *v, int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return class name of data type (see vtkType.h for definitions).
|
| GetMetaData(...)
| GetMetaData(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetMetaData(unsigned int idx)
| GetMetaData(self, iter:vtkCompositeDataIterator) -> vtkInformation
| C++: vtkInformation *GetMetaData(vtkCompositeDataIterator *iter)
| override;
|
| Returns the meta-data for the partition. If none is already
| present, a new vtkInformation object will be allocated. Use
| HasMetaData to avoid allocating vtkInformation objects.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfPartitions(...)
| GetNumberOfPartitions(self) -> int
| C++: unsigned int GetNumberOfPartitions()
|
| Returns the number of partitions.
|
| GetPartition(...)
| GetPartition(self, idx:int) -> vtkDataSet
| C++: vtkDataSet *GetPartition(unsigned int idx)
|
| Returns the partition at the given index.
|
| GetPartitionAsDataObject(...)
| GetPartitionAsDataObject(self, idx:int) -> vtkDataObject
| C++: vtkDataObject *GetPartitionAsDataObject(unsigned int idx)
|
| HasMetaData(...)
| HasMetaData(self, idx:int) -> int
| C++: vtkTypeBool HasMetaData(unsigned int idx)
| HasMetaData(self, iter:vtkCompositeDataIterator) -> int
| C++: vtkTypeBool HasMetaData(vtkCompositeDataIterator *iter)
| override;
|
| Returns true if meta-data is available for a given partition.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkPartitionedDataSet
| C++: vtkPartitionedDataSet *NewInstance()
|
| RemoveNullPartitions(...)
| RemoveNullPartitions(self) -> None
| C++: void RemoveNullPartitions()
|
| Removes all partitions that have null datasets and resizes the
| dataset. Note any meta data associated with the null datasets
| will get lost.
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkPartitionedDataSet
| C++: static vtkPartitionedDataSet *SafeDownCast(vtkObjectBase *o)
|
| SetNumberOfPartitions(...)
| SetNumberOfPartitions(self, numPartitions:int) -> None
| C++: void SetNumberOfPartitions(unsigned int numPartitions)
|
| Set the number of partitions. This will cause allocation if the
| new number of partitions is greater than the current size. All
| new partitions are initialized to null.
|
| SetPartition(...)
| SetPartition(self, idx:int, partition:vtkDataObject) -> None
| C++: void SetPartition(unsigned int idx, vtkDataObject *partition)
|
| Sets the data object as the given partition. The total number of
| partitions will be resized to fit the requested partition no.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkPartitionedDataSet:
|
| __this__
| Pointer to the C++ object.
|
| data_object_type
| read-only, calls GetDataObjectType
|
| number_of_partitions
| read-write, calls GetNumberOfPartitions/SetNumberOfPartitions
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkPartitionedDataSet:
|
| __vtkname__ = 'vtkPartitionedDataSet'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObjectTree:
|
| CompositeShallowCopy(...)
| CompositeShallowCopy(self, src:vtkCompositeDataSet) -> None
| C++: void CompositeShallowCopy(vtkCompositeDataSet *src) override;
|
| CompositeShallow, Shallow and Deep copy.
|
| CopyStructure(...)
| CopyStructure(self, input:vtkCompositeDataSet) -> None
| C++: void CopyStructure(vtkCompositeDataSet *input) override;
|
| Copies the tree structure from the input. All pointers to
| non-composite data objects are initialized to nullptr. This also
| shallow copies the meta data associated with all the nodes.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated.
|
| GetChild(...)
| GetChild(self, index:int) -> vtkDataObject
| C++: vtkDataObject *GetChild(unsigned int index)
|
| Returns a child dataset at a given index.
|
| GetChildMetaData(...)
| GetChildMetaData(self, index:int) -> vtkInformation
| C++: vtkInformation *GetChildMetaData(unsigned int index)
|
| Returns the meta-data at a given index. If the index is valid,
| however, no information object is set, then a new one will
| created and returned. To avoid unnecessary creation, use
| HasMetaData().
|
| GetDataSet(...)
| GetDataSet(self, iter:vtkCompositeDataIterator) -> vtkDataObject
| C++: vtkDataObject *GetDataSet(vtkCompositeDataIterator *iter)
| override;
| GetDataSet(self, flatIndex:int) -> vtkDataObject
| C++: virtual vtkDataObject *GetDataSet(unsigned int flatIndex)
|
| Returns the dataset located at the position pointed by the
| iterator. The iterator does not need to be iterating over this
| dataset itself. It can be an iterator for composite dataset with
| similar structure (achieved by using CopyStructure).
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| Returns the total number of cells of all blocks. This will
| iterate over all blocks and call GetNumberOfPoints() so it might
| be expensive.
|
| GetNumberOfChildren(...)
| GetNumberOfChildren(self) -> int
| C++: unsigned int GetNumberOfChildren()
|
| Get the number of children.
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| Returns the total number of points of all blocks. This will
| iterate over all blocks and call GetNumberOfPoints() so it might
| be expansive.
|
| HasChildMetaData(...)
| HasChildMetaData(self, index:int) -> int
| C++: vtkTypeBool HasChildMetaData(unsigned int index)
|
| Returns if meta-data information is available for the given child
| index. Returns 1 is present, 0 otherwise.
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Restore data object to initial state,
|
| NewIterator(...)
| NewIterator(self) -> vtkCompositeDataIterator
| C++: vtkCompositeDataIterator *NewIterator() override;
|
| Return a new iterator (the iterator has to be deleted by user).
|
| * Use NewTreeIterator when you have a pointer to a
| vtkDataObjectTree
| * and NewIterator when you have a pointer to a
| vtkCompositeDataSet;
| * NewIterator is inherited and calls NewTreeIterator internally.
|
| NewTreeIterator(...)
| NewTreeIterator(self) -> vtkDataObjectTreeIterator
| C++: virtual vtkDataObjectTreeIterator *NewTreeIterator()
|
| Return a new iterator (the iterator has to be deleted by user).
|
| SetDataSet(...)
| SetDataSet(self, iter:vtkCompositeDataIterator,
| dataObj:vtkDataObject) -> None
| C++: void SetDataSet(vtkCompositeDataIterator *iter,
| vtkDataObject *dataObj) override;
|
| Sets the data set at the location pointed by the iterator. The
| iterator does not need to be iterating over this dataset itself.
| It can be any composite datasite with similar structure (achieved
| by using CopyStructure).
|
| SetDataSetFrom(...)
| SetDataSetFrom(self, iter:vtkDataObjectTreeIterator,
| dataObj:vtkDataObject) -> None
| C++: void SetDataSetFrom(vtkDataObjectTreeIterator *iter,
| vtkDataObject *dataObj)
|
| Sets the data at the location provided by a
| vtkDataObjectTreeIterator
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the data up to the array
| pointers only. The implementation is delegated to the differenent
| subclasses. If you want to copy the actual data, @see DeepCopy.
|
| This method shallow copy the field data and copy the internal
| structure.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObjectTree:
|
| number_of_cells
| read-only, calls GetNumberOfCells
|
| number_of_children
| read-only, calls GetNumberOfChildren
|
| number_of_points
| read-only, calls GetNumberOfPoints
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkCompositeDataSet:
|
| CURRENT_PROCESS_CAN_LOAD_BLOCK(...)
| CURRENT_PROCESS_CAN_LOAD_BLOCK() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CURRENT_PROCESS_CAN_LOAD_BLOCK(
| )
|
| Key used to indicate that the current process can load the data
| in the node. Used for parallel readers where the nodes are
| assigned to the processes by the reader to indicate further down
| the pipeline which nodes will be on which processes.
| ***THIS IS AN EXPERIMENTAL KEY SUBJECT TO CHANGE WITHOUT
| NOTICE***\ingroup InformationKeys
|
| GetBounds(...)
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return the geometric bounding box in the form (xmin,xmax,
| ymin,ymax, zmin,zmax). Note that if the composite dataset
| contains abstract types (i.e., non vtkDataSet types) such as
| tables these will be ignored by the method. In cases where no
| vtkDataSet is contained in the composite dataset then the
| returned bounds will be undefined. THIS METHOD IS THREAD SAFE IF
| FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT
| MODIFIED.
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| NAME(...)
| NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *NAME()
|
| Key used to put node name in the meta-data associated with a
| node.\ingroup InformationKeys
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: virtual void Crop(const int *updateExtent)
|
| This method crops the data object (if necessary) so that the
| extent matches the update extent.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: virtual vtkFieldData *GetAttributesAsFieldData(int type)
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: virtual int GetExtentType()
|
| The ExtentType will be left as VTK_PIECES_EXTENT for data objects
| such as vtkPolyData and vtkUnstructuredGrid. The ExtentType will
| be changed to VTK_3D_EXTENT for data objects with 3D structure
| such as vtkImageData (and its subclass vtkStructuredPoints),
| vtkRectilinearGrid, and vtkStructuredGrid. The default is the
| have an extent in pieces, with only one piece (no streaming
| possible).
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: virtual vtkUnsignedCharArray *GetGhostArray(int type)
|
| Returns the ghost arrays of the data object of the specified
| attribute type. The type may be: POINT - Defined in
| vtkDataSet subclasses CELL - Defined in vtkDataSet subclasses.
| The other attribute types, will return nullptr since ghosts
| arrays are not defined for now outside of point or cell.
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Data objects are composite objects and need to check each part
| for MTime. The information object also needs to be considered.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| extent_type
| read-only, calls GetExtentType
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| m_time
| read-only, calls GetMTime
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.Plane
Python Library Documentation: function Plane in module pyvista.core.utilities.geometric_objects
Plane(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (0.0, 0.0, 1.0), i_size: 'float' = 1.0, j_size: 'float' = 1.0, i_resolution: 'int' = 10, j_resolution: 'int' = 10) -> 'PolyData'
Create a plane.
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Location of the centroid in ``[x, y, z]``.
direction : sequence[float], default: (0.0, 0.0, 1.0)
Direction of the plane's normal in ``[x, y, z]``.
i_size : float, default: 1.0
Size of the plane in the i direction.
j_size : float, default: 1.0
Size of the plane in the j direction.
i_resolution : int, default: 10
Number of points on the plane in the i direction.
j_resolution : int, default: 10
Number of points on the plane in the j direction.
Returns
-------
pyvista.PolyData
Plane mesh.
Examples
--------
Create a default plane.
>>> import pyvista as pv
>>> mesh = pv.Plane()
>>> mesh.point_data.clear()
>>> mesh.plot(show_edges=True)
pyvista.PlaneSource
Python Library Documentation: class PlaneSource in module pyvista.core.utilities.geometric_sources
class PlaneSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkPlaneSource)
| PlaneSource(*args, **kwargs) -> '_T'
|
| Create a plane source.
|
| The plane is defined by specifying an origin point, and then
| two other points that, together with the origin, define two
| axes for the plane (magnitude and direction). These axes do
| not have to be orthogonal - so you can create a parallelogram.
| The axes must not be parallel.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| i_resolution : int, default: 10
| Number of points on the plane in the i direction.
|
| j_resolution : int, default: 10
| Number of points on the plane in the j direction.
|
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Center in ``[x, y, z]``.
|
| origin : sequence[float], default: (-0.5, -0.5, 0.0)
| Origin in ``[x, y, z]``.
|
| point_a : sequence[float], default: (0.5, -0.5, 0.0)
| Location in ``[x, y, z]``.
|
| point_b : sequence[float], default: (-0.5, 0.5, 0.0)
| Location in ``[x, y, z]``.
|
| Method resolution order:
| PlaneSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkPlaneSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'PlaneSource', i_resolution: 'int' = 10, j_resolution: 'int' = 10, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), origin: 'VectorLike[float]' = (-0.5, -0.5, 0.0), point_a: 'VectorLike[float]' = (0.5, -0.5, 0.0), point_b: 'VectorLike[float]' = (-0.5, 0.5, 0.0)) -> 'None'
| Initialize source.
|
| flip_normal(self: 'PlaneSource') -> 'None'
| Flip the plane's normal.
|
| This method modifies the plane's :attr:`point_a` and :attr:`point_b` by
| swapping them.
|
| push(self: 'PlaneSource', distance: 'float') -> 'None'
| Translate the plane in the direction of the normal by the distance specified.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| normal
| Get the plane's normal vector.
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Plane mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Get the center in ``[x, y, z]``.
|
| The center of the plane is translated to the specified point.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``.
|
| i_resolution
| Number of points on the plane in the i direction.
|
| Returns
| -------
| int
| Number of points on the plane in the i direction.
|
| j_resolution
| Number of points on the plane in the j direction.
|
| Returns
| -------
| int
| Number of points on the plane in the j direction.
|
| origin
| Get the origin in ``[x, y, z]``.
|
| Returns
| -------
| sequence[float]
| Origin in ``[x, y, z]``.
|
| point_a
| Get the Location in ``[x, y, z]``.
|
| Returns
| -------
| sequence[float]
| Location in ``[x, y, z]``.
|
| point_b
| Get the Location in ``[x, y, z]``.
|
| Returns
| -------
| sequence[float]
| Location in ``[x, y, z]``.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkPlaneSource:
|
| GetAxis1(...)
| GetAxis1(self, a1:[float, float, float]) -> None
| C++: void GetAxis1(double a1[3])
|
| Convenience methods to retrieve the axes of the plane; that is
| axis a1 is the vector (Point1-Origin), and axis a2 is the vector
| (Point2-Origin).
|
| GetAxis2(...)
| GetAxis2(self, a2:[float, float, float]) -> None
| C++: void GetAxis2(double a2[3])
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetNormal(...)
| GetNormal(self) -> (float, float, float)
| C++: virtual double *GetNormal()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOrigin(...)
| GetOrigin(self) -> (float, float, float)
| C++: virtual double *GetOrigin()
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetPoint1(...)
| GetPoint1(self) -> (float, float, float)
| C++: virtual double *GetPoint1()
|
| GetPoint2(...)
| GetPoint2(self) -> (float, float, float)
| C++: virtual double *GetPoint2()
|
| GetResolution(...)
| GetResolution(self, xR:int, yR:int) -> None
| C++: void GetResolution(int &xR, int &yR)
|
| GetXResolution(...)
| GetXResolution(self) -> int
| C++: virtual int GetXResolution()
|
| GetYResolution(...)
| GetYResolution(self) -> int
| C++: virtual int GetYResolution()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkPlaneSource
| C++: vtkPlaneSource *NewInstance()
|
| Push(...)
| Push(self, distance:float) -> None
| C++: void Push(double distance)
|
| Translate the plane in the direction of the normal by the
| distance specified. Negative values move the plane in the
| opposite direction.
|
| Rotate(...)
| Rotate(self, angle:float, rotationAxis:[float, float, float])
| -> None
| C++: void Rotate(double angle, double rotationAxis[3])
|
| Rotate plane at center around a given axis If the absolute value
| of the angle is inferior to the defined EPSILON, then don't
| rotate
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkPlaneSource
| C++: static vtkPlaneSource *SafeDownCast(vtkObjectBase *o)
|
| SetCenter(...)
| SetCenter(self, x:float, y:float, z:float) -> None
| C++: void SetCenter(double x, double y, double z)
| SetCenter(self, center:[float, float, float]) -> None
| C++: void SetCenter(double center[3])
|
| Set/Get the center of the plane. Works in conjunction with the
| plane normal to position the plane. Don't use this method to
| define the plane. Instead, use it to move the plane to a new
| center point.
|
| SetNormal(...)
| SetNormal(self, nx:float, ny:float, nz:float) -> None
| C++: void SetNormal(double nx, double ny, double nz)
| SetNormal(self, n:[float, float, float]) -> None
| C++: void SetNormal(double n[3])
|
| Set/Get the plane normal. Works in conjunction with the plane
| center to orient the plane. Don't use this method to define the
| plane. Instead, use it to rotate the plane around the current
| center point.
|
| SetOrigin(...)
| SetOrigin(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetOrigin(double _arg1, double _arg2,
| double _arg3)
| SetOrigin(self, _arg:(float, float, float)) -> None
| C++: virtual void SetOrigin(const double _arg[3])
|
| Specify a point defining the origin of the plane.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetPoint1(...)
| SetPoint1(self, x:float, y:float, z:float) -> None
| C++: void SetPoint1(double x, double y, double z)
| SetPoint1(self, pnt:[float, float, float]) -> None
| C++: void SetPoint1(double pnt[3])
|
| Specify a point defining the first axis of the plane.
|
| SetPoint2(...)
| SetPoint2(self, x:float, y:float, z:float) -> None
| C++: void SetPoint2(double x, double y, double z)
| SetPoint2(self, pnt:[float, float, float]) -> None
| C++: void SetPoint2(double pnt[3])
|
| Specify a point defining the second axis of the plane.
|
| SetResolution(...)
| SetResolution(self, xR:int, yR:int) -> None
| C++: void SetResolution(int xR, int yR)
|
| Set the number of x-y subdivisions in the plane.
|
| SetXResolution(...)
| SetXResolution(self, _arg:int) -> None
| C++: virtual void SetXResolution(int _arg)
|
| Specify the resolution of the plane along the first axes.
|
| SetYResolution(...)
| SetYResolution(self, _arg:int) -> None
| C++: virtual void SetYResolution(int _arg)
|
| Specify the resolution of the plane along the second axes.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkPlaneSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkPlaneSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkPlaneSource:
|
| __this__
| Pointer to the C++ object.
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| point1
| read-write, calls GetPoint1/SetPoint1
|
| point2
| read-write, calls GetPoint2/SetPoint2
|
| resolution
| write-only, calls SetResolution
|
| x_resolution
| read-write, calls GetXResolution/SetXResolution
|
| y_resolution
| read-write, calls GetYResolution/SetYResolution
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkPlaneSource:
|
| __vtkname__ = 'vtkPlaneSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.PlatonicSolid
Python Library Documentation: function PlatonicSolid in module pyvista.core.utilities.geometric_objects
PlatonicSolid(kind: 'str' = 'tetrahedron', radius: 'float' = 1.0, center: 'VectorLike[float]' = (0.0, 0.0, 0.0)) -> 'PolyData'
Create a Platonic solid of a given size.
Parameters
----------
kind : str | int, default: 'tetrahedron'
The kind of Platonic solid to create. Either the name of the
polyhedron or an integer index:
* ``'tetrahedron'`` or ``0``
* ``'cube'`` or ``1``
* ``'octahedron'`` or ``2``
* ``'icosahedron'`` or ``3``
* ``'dodecahedron'`` or ``4``
radius : float, default: 1.0
The radius of the circumscribed sphere for the solid to create.
center : sequence[float], default: (0.0, 0.0, 0.0)
Sequence defining the center of the solid to create.
Returns
-------
pyvista.PolyData
One of the five Platonic solids. Cell scalars are defined that
assign integer labels to each face (with array name
``"FaceIndex"``).
Examples
--------
Create and plot a dodecahedron.
>>> import pyvista as pv
>>> dodeca = pv.PlatonicSolid('dodecahedron')
>>> dodeca.plot(categories=True)
See :ref:`create_platonic_solids_example` for more examples using this filter.
pyvista.PlatonicSolidSource
Python Library Documentation: class PlatonicSolidSource in module pyvista.core.utilities.geometric_sources
class PlatonicSolidSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource)
| PlatonicSolidSource(*args, **kwargs) -> '_T'
|
| Platonic solid source algorithm class.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| kind : str | int, default: 'tetrahedron'
| The kind of Platonic solid to create. Either the name of the
| polyhedron or an integer index:
|
| * ``'tetrahedron'`` or ``0``
| * ``'cube'`` or ``1``
| * ``'octahedron'`` or ``2``
| * ``'icosahedron'`` or ``3``
| * ``'dodecahedron'`` or ``4``
|
| Examples
| --------
| Create and plot a dodecahedron.
|
| >>> import pyvista as pv
| >>> dodeca = pv.PlatonicSolidSource('dodecahedron')
| >>> dodeca.output.plot(categories=True)
|
| See :ref:`create_platonic_solids_example` for more examples using this filter.
|
| Method resolution order:
| PlatonicSolidSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'PlatonicSolidSource', kind: 'str' = 'tetrahedron') -> 'None'
| Initialize the platonic solid source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| PlatonicSolid surface.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| kind
| Get the kind of Platonic solid to create.
|
| Returns
| -------
| str
| The kind of Platonic solid to create.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource:
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetSolidType(...)
| GetSolidType(self) -> int
| C++: virtual int GetSolidType()
|
| GetSolidTypeMaxValue(...)
| GetSolidTypeMaxValue(self) -> int
| C++: virtual int GetSolidTypeMaxValue()
|
| GetSolidTypeMinValue(...)
| GetSolidTypeMinValue(self) -> int
| C++: virtual int GetSolidTypeMinValue()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkPlatonicSolidSource
| C++: vtkPlatonicSolidSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkPlatonicSolidSource
| C++: static vtkPlatonicSolidSource *SafeDownCast(vtkObjectBase *o)
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetSolidType(...)
| SetSolidType(self, _arg:int) -> None
| C++: virtual void SetSolidType(int _arg)
|
| Specify the type of PlatonicSolid solid to create.
|
| SetSolidTypeToCube(...)
| SetSolidTypeToCube(self) -> None
| C++: void SetSolidTypeToCube()
|
| SetSolidTypeToDodecahedron(...)
| SetSolidTypeToDodecahedron(self) -> None
| C++: void SetSolidTypeToDodecahedron()
|
| SetSolidTypeToIcosahedron(...)
| SetSolidTypeToIcosahedron(self) -> None
| C++: void SetSolidTypeToIcosahedron()
|
| SetSolidTypeToOctahedron(...)
| SetSolidTypeToOctahedron(self) -> None
| C++: void SetSolidTypeToOctahedron()
|
| SetSolidTypeToTetrahedron(...)
| SetSolidTypeToTetrahedron(self) -> None
| C++: void SetSolidTypeToTetrahedron()
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource:
|
| __this__
| Pointer to the C++ object.
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| solid_type
| read-write, calls GetSolidType/SetSolidType
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource:
|
| __vtkname__ = 'vtkPlatonicSolidSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.Plot3DFunctionEnum
Python Library Documentation: class Plot3DFunctionEnum in module pyvista.core.utilities.reader class Plot3DFunctionEnum(enum.IntEnum) | Plot3DFunctionEnum(*values) | | An enumeration for the functions used in :class:`MultiBlockPlot3DReader`. | | Method resolution order: | Plot3DFunctionEnum | enum.IntEnum | builtins.int | enum.ReprEnum | enum.Enum | builtins.object | | Methods defined here: | | __format__(self, format_spec, /) from builtins.int | Convert to a string according to format_spec. | | __new__(cls, value) from enum.Enum | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | DENSITY = <Plot3DFunctionEnum.DENSITY: 100> | | ENTHALPY = <Plot3DFunctionEnum.ENTHALPY: 130> | | ENTROPY = <Plot3DFunctionEnum.ENTROPY: 170> | | INTERNAL_ENERGY = <Plot3DFunctionEnum.INTERNAL_ENERGY: 140> | | KINETIC_ENERGY = <Plot3DFunctionEnum.KINETIC_ENERGY: 144> | | MACH = <Plot3DFunctionEnum.MACH: 112> | | MOMENTUM = <Plot3DFunctionEnum.MOMENTUM: 202> | | PRESSURE = <Plot3DFunctionEnum.PRESSURE: 110> | | PRESSURE_COEFFICIENT = <Plot3DFunctionEnum.PRESSURE_COEFFICIENT: 111> | | PRESSURE_GRADIENT = <Plot3DFunctionEnum.PRESSURE_GRADIENT: 210> | | SPEED_OF_SOUND = <Plot3DFunctionEnum.SPEED_OF_SOUND: 113> | | STAGNATION_ENERGY = <Plot3DFunctionEnum.STAGNATION_ENERGY: 163> | | STRAIN_RATE = <Plot3DFunctionEnum.STRAIN_RATE: 212> | | SWIRL = <Plot3DFunctionEnum.SWIRL: 184> | | TEMPERATURE = <Plot3DFunctionEnum.TEMPERATURE: 120> | | VELOCITY = <Plot3DFunctionEnum.VELOCITY: 200> | | VELOCITY_MAGNITUDE = <Plot3DFunctionEnum.VELOCITY_MAGNITUDE: 153> | | VORTICITY = <Plot3DFunctionEnum.VORTICITY: 201> | | VORTICITY_MAGNITUDE = <Plot3DFunctionEnum.VORTICITY_MAGNITUDE: 211> | | ---------------------------------------------------------------------- | Methods inherited from enum.IntEnum: | | __repr__(self) from enum.Enum | Return repr(self). | | __str__ = __repr__(self, /) from builtins.int | Return repr(self). | | ---------------------------------------------------------------------- | Methods inherited from builtins.int: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | True if self else False | | __ceil__(...) | Ceiling of an Integral returns itself. | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floor__(...) | Flooring an Integral returns itself. | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(self, /) | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __round__(...) | Rounding an Integral returns itself. | | Rounding with an ndigits argument also returns an integer. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __sizeof__(self, /) | Returns size in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __trunc__(...) | Truncating an Integral returns itself. | | __xor__(self, value, /) | Return self^value. | | as_integer_ratio(self, /) | Return a pair of integers, whose ratio is equal to the original int. | | The ratio is in lowest terms and has a positive denominator. | | >>> (10).as_integer_ratio() | (10, 1) | >>> (-10).as_integer_ratio() | (-10, 1) | >>> (0).as_integer_ratio() | (0, 1) | | bit_count(self, /) | Number of ones in the binary representation of the absolute value of self. | | Also known as the population count. | | >>> bin(13) | '0b1101' | >>> (13).bit_count() | 3 | | bit_length(self, /) | Number of bits necessary to represent self in binary. | | >>> bin(37) | '0b100101' | >>> (37).bit_length() | 6 | | conjugate(...) | Returns self, the complex conjugate of any int. | | is_integer(self, /) | Returns True. Exists for duck type compatibility with float.is_integer. | | to_bytes(self, /, length=1, byteorder='big', *, signed=False) | Return an array of bytes representing an integer. | | length | Length of bytes object to use. An OverflowError is raised if the | integer is not representable with the given number of bytes. Default | is length 1. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Determines whether two's complement is used to represent the integer. | If signed is False and a negative integer is given, an OverflowError | is raised. | | ---------------------------------------------------------------------- | Class methods inherited from builtins.int: | | from_bytes(bytes, byteorder='big', *, signed=False) | Return the integer represented by the given array of bytes. | | bytes | Holds the array of bytes to convert. The argument must either | support the buffer protocol or be an iterable object producing bytes. | Bytes and bytearray are examples of built-in objects that support the | buffer protocol. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Indicates whether two's complement is used to represent the integer. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.int: | | denominator | the denominator of a rational number in lowest terms | | imag | the imaginary part of a complex number | | numerator | the numerator of a rational number in lowest terms | | real | the real part of a complex number | | ---------------------------------------------------------------------- | Methods inherited from enum.Enum: | | __dir__(self) | Returns public methods and other interesting attributes. | | __init__(self, *args, **kwds) | Initialize self. See help(type(self)) for accurate signature. | | __reduce_ex__(self, proto) | Helper for pickle. | | ---------------------------------------------------------------------- | Data descriptors inherited from enum.Enum: | | name | The name of the Enum member. | | value | The value of the Enum member. | | ---------------------------------------------------------------------- | Static methods inherited from enum.EnumType: | | __contains__(value) | Return True if `value` is in `cls`. | | `value` is in `cls` if: | 1) `value` is a member of `cls`, or | 2) `value` is the value of one of the `cls`'s members. | | __getitem__(name) | Return the member matching `name`. | | __iter__() | Return members in definition order. | | __len__() | Return the number of members (no aliases) | | ---------------------------------------------------------------------- | Readonly properties inherited from enum.EnumType: | | __members__ | Returns a mapping of member name->value. | | This mapping lists all enum members, including aliases. Note that this | is a read-only view of the internal mapping.
pyvista.Plot3DMetaReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.PointCellDataSelection
Python Library Documentation: class PointCellDataSelection in module pyvista.core.utilities.reader
class PointCellDataSelection(pyvista.core.utilities.misc._NoNewAttrMixin)
| PointCellDataSelection(*args, **kwargs) -> '_T'
|
| Mixin for readers that support data array selections.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> from pathlib import Path
| >>> filename = examples.download_backward_facing_step(load=False)
| >>> Path(filename).name
| 'foam_case_0_0_0_0.case'
| >>> reader = pv.get_reader(filename)
| >>> reader
| EnSightReader('.../foam_case_0_0_0_0.case')
| >>> reader.cell_array_names
| ['v2', 'nut', 'k', 'nuTilda', 'p', 'omega', 'f', 'epsilon', 'U']
| >>> reader.point_array_names
| []
| >>> reader.all_cell_arrays_status # doctest: +NORMALIZE_WHITESPACE
| {'v2': True, 'nut': True, 'k': True, 'nuTilda': True, 'p': True,
| 'omega': True, 'f': True, 'epsilon': True, 'U': True}
| >>> reader.disable_all_cell_arrays()
| >>> reader.enable_cell_array('U')
| >>> mesh = reader.read() # MultiBlock mesh
| >>> mesh[0].array_names
| ['U']
|
| Method resolution order:
| PointCellDataSelection
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| cell_array_status(self, name)
| Get status of cell array with name.
|
| Parameters
| ----------
| name : str
| Cell array name.
|
| Returns
| -------
| bool
| Whether reading the cell array is enabled.
|
| disable_all_cell_arrays(self) -> 'None'
| Disable all cell arrays.
|
| disable_all_point_arrays(self) -> 'None'
| Disable all point arrays.
|
| disable_cell_array(self, name) -> 'None'
| Disable cell array with name.
|
| Parameters
| ----------
| name : str
| Cell array name.
|
| disable_point_array(self, name) -> 'None'
| Disable point array with name.
|
| Parameters
| ----------
| name : str
| Point array name.
|
| enable_all_cell_arrays(self) -> 'None'
| Enable all cell arrays.
|
| enable_all_point_arrays(self) -> 'None'
| Enable all point arrays.
|
| enable_cell_array(self, name) -> 'None'
| Enable cell array with name.
|
| Parameters
| ----------
| name : str
| Cell array name.
|
| enable_point_array(self, name) -> 'None'
| Enable point array with name.
|
| Parameters
| ----------
| name : str
| Point array name.
|
| point_array_status(self, name)
| Get status of point array with name.
|
| Parameters
| ----------
| name : str
| Point array name.
|
| Returns
| -------
| bool
| Whether reading the cell array is enabled.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| all_cell_arrays_status
| Return the status of all cell arrays.
|
| Returns
| -------
| dict[str, bool]
| Name and if the cell array is available.
|
| all_point_arrays_status
| Return the status of all point arrays.
|
| Returns
| -------
| dict[str, bool]
| Status of all point arrays.
|
| cell_array_names
| Return the list of all cell array names.
|
| Returns
| -------
| list[str]
| List of all cell array names.
|
| number_cell_arrays
| Return the number of cell arrays.
|
| Returns
| -------
| int
| Number of cell arrays.
|
| number_point_arrays
| Return the number of point arrays.
|
| Returns
| -------
| int
| Number of point arrays.
|
| point_array_names
| Return the list of all point array names.
|
| Returns
| -------
| list[str]
| List of all point array names.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
pyvista.PointGrid
Python Library Documentation: class PointGrid in module pyvista.core.pointset
class PointGrid(_PointSet)
| PointGrid(*args, **kwargs) -> '_T'
|
| Class in common with structured and unstructured grids.
|
| Method resolution order:
| PointGrid
| _PointSet
| pyvista.core.dataset.DataSet
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| builtins.object
|
| Methods defined here:
|
| __init__(self, *args, **kwargs) -> 'None'
| Initialize the point grid.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| plot_curvature(self: 'Self', curv_type='mean', **kwargs)
| Plot the curvature of the external surface of the grid.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| One of the following strings indicating curvature types.
| - ``'mean'``
| - ``'gaussian'``
| - ``'maximum'``
| - ``'minimum'``
|
| **kwargs : dict, optional
| Optional keyword arguments. See :func:`pyvista.plot`.
|
| Returns
| -------
| list
| Camera position, focal point, and view up. Returned when
| ``return_cpos`` is ``True``.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from _PointSet:
|
| center_of_mass(self, scalars_weight: 'bool' = False) -> 'NumpyArray[float]'
| Return the coordinates for the center of mass of the mesh.
|
| Parameters
| ----------
| scalars_weight : bool, default: False
| Flag for using the mesh scalars as weights.
|
| Returns
| -------
| numpy.ndarray
| Coordinates for the center of mass.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 1, 1))
| >>> mesh.center_of_mass()
| array([1., 1., 1.])
|
| points_to_double(self) -> 'Self'
| Convert the points datatype to double precision.
|
| Returns
| -------
| pyvista.PointSet
| Pointset with points in double precision.
|
| Notes
| -----
| This operates in place.
|
| Examples
| --------
| Create a mesh that has points of the type ``float32`` and
| convert the points to ``float64``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.points.dtype
| dtype('float32')
| >>> _ = mesh.points_to_double()
| >>> mesh.points.dtype
| dtype('float64')
|
| remove_cells(self, ind: 'VectorLike[bool] | VectorLike[int]', inplace: 'bool' = False) -> '_PointSet'
| Remove cells.
|
| Parameters
| ----------
| ind : VectorLike[int] | VectorLike[bool]
| Cell indices to be removed. The array can also be a
| boolean array of the same size as the number of cells.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| Returns
| -------
| pyvista.DataSet
| Same type as the input, but with the specified cells
| removed.
|
| See Also
| --------
| :ref:`ghost_cells_example`
|
| Examples
| --------
| Remove 20 cells from an unstructured grid.
|
| >>> from pyvista import examples
| >>> import pyvista as pv
| >>> hex_mesh = pv.read(examples.hexbeamfile)
| >>> removed = hex_mesh.remove_cells(range(10, 20))
| >>> removed.plot(color='lightblue', show_edges=True, line_width=3)
|
| shallow_copy(self, to_copy: 'DataSet') -> 'None'
| Create a shallow copy from a different dataset into this one.
|
| This method mutates this dataset and returns ``None``.
|
| Parameters
| ----------
| to_copy : pyvista.DataSet
| Data object to perform the shallow copy from.
|
| translate(self: 'Self', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False)
| Translate the mesh.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats of cartesian values to translate the mesh with.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed. This is
| only valid when not updating in place.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PointSet
| Translated pointset.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=True)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __repr__(self: 'Self') -> 'str'
| Return the object representation.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| __str__(self: 'Self') -> 'str'
| Return the object string representation.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
pyvista.PointSet
Python Library Documentation: class PointSet in module pyvista.core.pointset
class PointSet(_PointSet, vtkmodules.vtkCommonDataModel.vtkPointSet)
| PointSet(*args, **kwargs) -> '_T'
|
| Concrete class for storing a set of points.
|
| This is a concrete class representing a set of points that specifies the
| interface for datasets that explicitly use "point" arrays to represent
| geometry. This class is useful for improving the performance of filters on
| point clouds, but not plotting.
|
| For further details see :vtk:`vtkPointSet`.
|
| Parameters
| ----------
| var_inp : :vtk:`vtkPointSet`, MatrixLike[float], optional
| Flexible input type. Can be a :vtk:`vtkPointSet`, in which case
| this PointSet object will be copied if ``deep=True`` and will
| be a shallow copy if ``deep=False``.
|
| List, numpy array, or sequence containing point locations. Must be an
| ``(N, 3)`` array of points.
|
| deep : bool, default: False
| Whether to copy the input ``points``, or to create a PointSet from them
| without copying them. Setting ``deep=True`` ensures that the original
| arrays can be modified outside the mesh without affecting the
| mesh.
|
| force_float : bool, default: True
| Casts the datatype to ``float32`` if points datatype is non-float. Set
| this to ``False`` to allow non-float types, though this may lead to
| truncation of intermediate floats when transforming datasets.
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| Create a simple point cloud of 10 points from a numpy array.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> rng = np.random.default_rng(seed=0)
| >>> points = rng.random((10, 3))
| >>> pset = pv.PointSet(points)
|
| Plot the pointset. Note: this casts to a :class:`pyvista.PolyData`
| internally when plotting.
|
| >>> pset.plot(point_size=10)
|
| Method resolution order:
| PointSet
| _PointSet
| pyvista.core.dataset.DataSet
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkPointSet
| vtkmodules.vtkCommonDataModel.vtkDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, var_inp=None, deep: 'bool' = False, force_float: 'bool' = True, *, validate: 'bool | _NestedMeshValidationFields' = False) -> 'None'
| Initialize the pointset.
|
| __repr__(self)
| Return the standard representation.
|
| __str__(self)
| Return the standard str representation.
|
| cast_to_polydata(self, deep: 'bool' = True)
| Cast this dataset to polydata.
|
| Parameters
| ----------
| deep : bool, deep: True
| Whether to copy the pointset points, or to create a PolyData
| without copying them. Setting ``deep=True`` ensures that the
| original arrays can be modified outside the PolyData without
| affecting the PolyData.
|
| Returns
| -------
| pyvista.PolyData
| PointSet cast to a ``pyvista.PolyData``.
|
| cast_to_unstructured_grid(self) -> 'pv.UnstructuredGrid'
| Cast this dataset to :class:`pyvista.UnstructuredGrid`.
|
| A deep copy of the points and point data is made.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast to a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PointSet` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cloud_dark_matter()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PointSet'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_data_to_point_data(self, *args, **kwargs)
| Raise PointSets do not have cells.
|
| cell_validator(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| contour(self, *args, **kwargs)
| Raise dimension reducing operations are not supported.
|
| decimate_boundary(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False) from pyvista.core.filters.data_set.DataSetFilters
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1) from pyvista.core.filters.data_set.DataSetFilters
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_geometry(self, *args, **kwargs)
| Raise extract geometry are not supported.
|
| ..deprecated:: 0.47
|
| extract_surface(self, *args, **kwargs)
| Raise extract surface are not supported.
|
| find_cells_along_line(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_data_to_cell_data(self, *args, **kwargs)
| Raise PointSets do not have cells.
|
| point_is_inside_cell(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| remove_cells(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| separate_cells(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| shrink(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| slice(self, *args, **kwargs)
| Raise dimension reducing operations are not supported.
|
| slice_along_axis(self, *args, **kwargs)
| Raise dimension reducing operations are not supported.
|
| slice_along_line(self, *args, **kwargs)
| Raise dimension reducing operations are not supported.
|
| slice_implicit(self, *args, **kwargs)
| Raise dimension reducing operations are not supported.
|
| slice_orthogonal(self, *args, **kwargs)
| Raise dimension reducing operations are not supported.
|
| tessellate(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False) from pyvista.core.filters.data_set.DataSetFilters
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False) from pyvista.core.filters.data_set.DataSetFilters
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| triangulate(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| area
| Return 0.0 since a PointSet has no area.
|
| volume
| Return 0.0 since a PointSet has no volume.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from _PointSet:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| center_of_mass(self, scalars_weight: 'bool' = False) -> 'NumpyArray[float]'
| Return the coordinates for the center of mass of the mesh.
|
| Parameters
| ----------
| scalars_weight : bool, default: False
| Flag for using the mesh scalars as weights.
|
| Returns
| -------
| numpy.ndarray
| Coordinates for the center of mass.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 1, 1))
| >>> mesh.center_of_mass()
| array([1., 1., 1.])
|
| points_to_double(self) -> 'Self'
| Convert the points datatype to double precision.
|
| Returns
| -------
| pyvista.PointSet
| Pointset with points in double precision.
|
| Notes
| -----
| This operates in place.
|
| Examples
| --------
| Create a mesh that has points of the type ``float32`` and
| convert the points to ``float64``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.points.dtype
| dtype('float32')
| >>> _ = mesh.points_to_double()
| >>> mesh.points.dtype
| dtype('float64')
|
| shallow_copy(self, to_copy: 'DataSet') -> 'None'
| Create a shallow copy from a different dataset into this one.
|
| This method mutates this dataset and returns ``None``.
|
| Parameters
| ----------
| to_copy : pyvista.DataSet
| Data object to perform the shallow copy from.
|
| translate(self: 'Self', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False)
| Translate the mesh.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats of cartesian values to translate the mesh with.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed. This is
| only valid when not updating in place.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PointSet
| Translated pointset.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=True)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| BuildCellLocator(...)
| BuildCellLocator(self) -> None
| C++: void BuildCellLocator()
|
| Build the cell locator. In a multi-threaded environment, call
| this method in a single thread before using FindCell().
|
| BuildLocator(...)
| BuildLocator(self) -> None
| C++: void BuildLocator()
|
| BuildPointLocator(...)
| BuildPointLocator(self) -> None
| C++: void BuildPointLocator()
|
| Build the internal point locator . In a multi-threaded
| environment, call this method in a single thread before using
| FindCell() or FindPoint().
|
| ComputeBounds(...)
| ComputeBounds(self) -> None
| C++: void ComputeBounds() override;
|
| Compute the (X, Y, Z) bounds of the data.
|
| CopyStructure(...)
| CopyStructure(self, pd:vtkDataSet) -> None
| C++: void CopyStructure(vtkDataSet *pd) override;
|
| Copy the geometric structure of an input point set object.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| EditableOff(...)
| EditableOff(self) -> None
| C++: virtual void EditableOff()
|
| EditableOn(...)
| EditableOn(self) -> None
| C++: virtual void EditableOn()
|
| ExtendedNew(...)
| ExtendedNew() -> vtkPointSet
| C++: static vtkPointSet *ExtendedNew()
|
| FindCell(...)
| FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int,
| tol2:float, subId:int, pcoords:[float, float, float],
| weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
| FindCell(self, x:[float, float, float], cell:vtkCell,
| gencell:vtkGenericCell, cellId:int, tol2:float, subId:int,
| pcoords:[float, float, float], weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkGenericCell *gencell, vtkIdType cellId, double tol2,
| int &subId, double pcoords[3], double *weights) override;
|
| Locate cell based on global coordinate x and tolerance squared.
| If cell and cellId is non-nullptr, then search starts from this
| cell and looks at immediate neighbors. Returns cellId >= 0 if
| inside, < 0 otherwise. The parametric coordinates are provided
| in pcoords[3]. The interpolation weights are returned in
| weights[]. (The number of weights is equal to the number of
| points in the found cell). Tolerance is used to control how close
| the point is to be considered "in" the cell. THIS METHOD IS NOT
| THREAD SAFE.
|
| FindPoint(...)
| FindPoint(self, x:[float, float, float]) -> int
| C++: vtkIdType FindPoint(double x[3]) override;
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated. The
| memory size returned is guaranteed to be greater than or equal to
| the memory required to represent the data (e.g., extra space in
| arrays, etc. are not included in the return value). THIS METHOD
| IS THREAD SAFE.
|
| GetCell(...)
| GetCell(self, __a:int) -> vtkCell
| C++: vtkCell *GetCell(vtkIdType) override;
| GetCell(self, __a:int, cell:vtkGenericCell) -> None
| C++: void GetCell(vtkIdType, vtkGenericCell *cell) override;
| GetCell(self, i:int, j:int, k:int) -> vtkCell
| C++: virtual vtkCell *GetCell(int i, int j, int k)
|
| This method always return a `vtkEmptyCell`, as there is no cell
| in a `vtkPointSet`.
|
| GetCellLocator(...)
| GetCellLocator(self) -> vtkAbstractCellLocator
| C++: virtual vtkAbstractCellLocator *GetCellLocator()
|
| GetCellPoints(...)
| GetCellPoints(self, __a:int, idList:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType, vtkIdList *idList) override;
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...),
| ptIds:vtkIdList) -> None
| C++: virtual void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts, vtkIdList *ptIds)
|
| Topological inquiry to get points defining cell. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| GetCellSize(...)
| GetCellSize(self, __a:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType) override;
|
| This method always returns 1, as all cells are point in a pure
| `vtkPointSet`.
|
| GetCellType(...)
| GetCellType(self, __a:int) -> int
| C++: int GetCellType(vtkIdType) override;
|
| This method always returns `VTK_EMPTY_CELL`, as there is no cell
| in a `vtkPointSet`.
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkPointSet
| C++: static vtkPointSet *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkPointSet
| C++: static vtkPointSet *GetData(vtkInformationVector *v, int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Standard vtkDataSet API methods. See vtkDataSet for more
| information.
|
| GetEditable(...)
| GetEditable(self) -> bool
| C++: virtual bool GetEditable()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Get MTime which also considers its vtkPoints MTime.
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Convenience method returns largest cell size in dataset. This is
| generally used to allocate memory for supporting data structures.
| THIS METHOD IS THREAD SAFE
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| This method always returns 0, as there are no cells in a
| `vtkPointSet`.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| See vtkDataSet for additional information.
|
| GetPoint(...)
| GetPoint(self, ptId:int, x:[float, float, float]) -> None
| C++: void GetPoint(vtkIdType ptId, double x[3]) override;
| GetPoint(self, ptId:int) -> (float, float, float)
| C++: double *GetPoint(vtkIdType ptId) override;
|
| Copy point coordinates into user provided array x[3] for
| specified point id. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetPointCells(...)
| GetPointCells(self, __a:int, idList:vtkIdList) -> None
| C++: void GetPointCells(vtkIdType, vtkIdList *idList) override;
|
| Topological inquiry to get cells using point. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| GetPointLocator(...)
| GetPointLocator(self) -> vtkAbstractPointLocator
| C++: virtual vtkAbstractPointLocator *GetPointLocator()
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints() override;
|
| If the subclass has (implicit/explicit) points, then return them.
| Otherwise, create a vtkPoints object and return that.
|
| DO NOT MODIFY THE RETURNED POINTS OBJECT.
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Reset to an empty state and free any memory.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewCellIterator(...)
| NewCellIterator(self) -> vtkCellIterator
| C++: vtkCellIterator *NewCellIterator() override;
|
| Return an iterator that traverses the cells in this data set.
|
| NewInstance(...)
| NewInstance(self) -> vtkPointSet
| C++: vtkPointSet *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkPointSet
| C++: static vtkPointSet *SafeDownCast(vtkObjectBase *o)
|
| SetCellLocator(...)
| SetCellLocator(self, __a:vtkAbstractCellLocator) -> None
| C++: virtual void SetCellLocator(vtkAbstractCellLocator *)
|
| Set / get an instance of vtkAbstractCellLocator which may be used
| when a vtkCellLocatorStrategy is used during a FindCell()
| operation.
|
| SetEditable(...)
| SetEditable(self, _arg:bool) -> None
| C++: virtual void SetEditable(bool _arg)
|
| Specify whether this dataset is editable after creation. Meaning,
| once the points and cells are defined, can the dataset be
| incrementally modified. By default, this dataset is non-editable
| (i.e., "static") after construction. The reason for this is
| performance: cell links and locators can be built (and destroyed)
| much faster is it is known that the data is static (see
| vtkStaticCellLinks, vtkStaticPointLocator, vtkStaticCellLocator).
|
| SetPointLocator(...)
| SetPointLocator(self, __a:vtkAbstractPointLocator) -> None
| C++: virtual void SetPointLocator(vtkAbstractPointLocator *)
|
| Set / get an instance of vtkAbstractPointLocator which is used to
| support the FindPoint() and FindCell() methods. By default a
| vtkStaticPointLocator is used, unless the class is set as
| Editable, in which case a vtkPointLocator is used.
|
| SetPoints(...)
| SetPoints(self, __a:vtkPoints) -> None
| C++: virtual void SetPoints(vtkPoints *)
|
| Specify point array to define point coordinates.
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: void Squeeze() override;
|
| Reclaim any unused memory.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Overwritten to handle the data/locator loop
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| __this__
| Pointer to the C++ object.
|
| cell_locator
| read-write, calls GetCellLocator/SetCellLocator
|
| data_object_type
| read-only, calls GetDataObjectType
|
| editable
| read-write, calls GetEditable/SetEditable
|
| m_time
| read-only, calls GetMTime
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| point_locator
| read-write, calls GetPointLocator/SetPointLocator
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| __vtkname__ = 'vtkPointSet'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| AllocateCellGhostArray(...)
| AllocateCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocateCellGhostArray()
|
| Allocate ghost array for cells.
|
| AllocatePointGhostArray(...)
| AllocatePointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocatePointGhostArray()
|
| Allocate ghost array for points.
|
| CheckAttributes(...)
| CheckAttributes(self) -> int
| C++: int CheckAttributes()
|
| This method checks to see if the cell and point attributes match
| the geometry. Many filters will crash if the number of tuples in
| an array is less than the number of points/cells. This method
| returns 1 if there is a mismatch, and 0 if everything is ok. It
| prints an error if an array is too short, and a warning if an
| array is too long.
|
| CopyAttributes(...)
| CopyAttributes(self, ds:vtkDataSet) -> None
| C++: virtual void CopyAttributes(vtkDataSet *ds)
|
| Copy the attributes associated with the specified dataset to this
| instance of vtkDataSet. THIS METHOD IS NOT THREAD SAFE.
|
| FindAndGetCell(...)
| FindAndGetCell(self, x:[float, float, float], cell:vtkCell,
| cellId:int, tol2:float, subId:int, pcoords:[float, float,
| float], weights:[float, ...]) -> vtkCell
| C++: virtual vtkCell *FindAndGetCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights)
|
| Locate the cell that contains a point and return the cell. Also
| returns the subcell id, parametric coordinates and weights for
| subsequent interpolation. This method combines the derived class
| methods int FindCell and vtkCell *GetCell. Derived classes may
| provide a more efficient implementation. See for example
| vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE.
|
| GenerateGhostArray(...)
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int])
| -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6])
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int],
| cellOnly:bool) -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6],
| bool cellOnly)
|
| Normally called by pipeline executives or algorithms only. This
| method computes the ghost arrays for a given dataset. The zeroExt
| argument specifies the extent of the region which ghost type = 0.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return a pointer to the geometry bounding box in the form
| (xmin,xmax, ymin,ymax, zmin,zmax). THIS METHOD IS NOT THREAD
| SAFE.
|
| GetCellBounds(...)
| GetCellBounds(self, cellId:int, bounds:[float, float, float,
| float, float, float]) -> None
| C++: virtual void GetCellBounds(vtkIdType cellId,
| double bounds[6])
|
| Get the bounds of the cell with cellId such that: 0 <= cellId <
| NumberOfCells. A subclass may be able to determine the bounds of
| cell without using an expensive GetCell() method. A default
| implementation is provided that actually uses a GetCell() call.
| This is to ensure the method is available to all datasets.
| Subclasses should override this method to provide an efficient
| implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetCellData(...)
| GetCellData(self) -> vtkCellData
| C++: vtkCellData *GetCellData()
|
| Return a pointer to this dataset's cell data. THIS METHOD IS
| THREAD SAFE
|
| GetCellGhostArray(...)
| GetCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellGhostArray()
|
| Get the array that defines the ghost type of each cell. We cache
| the pointer to the array to save a lookup involving string
| comparisons
|
| GetCellNeighbors(...)
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList) -> None
| C++: virtual void GetCellNeighbors(vtkIdType cellId,
| vtkIdList *ptIds, vtkIdList *cellIds)
|
| Topological inquiry to get all cells using list of points
| exclusive of cell specified (e.g., cellId). Note that the list
| consists of only cells that use ALL the points provided. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetCellNumberOfFaces(...)
| GetCellNumberOfFaces(self, cellId:int, cellType:int,
| cell:vtkGenericCell) -> int
| C++: virtual int GetCellNumberOfFaces(vtkIdType cellId,
| unsigned char &cellType, vtkGenericCell *cell)
|
| Get the number of faces of a cell.
|
| Most of the times extracting the number of faces requires only
| extracting the cell type. However, for some cell types, the
| number of faces is not constant. For example, a convex point set
| cell can have a different number of faces for each cell. That's
| why this method requires the cell id and the dataset.
|
| GetCellTypes(...)
| GetCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetCellTypes(vtkCellTypes *types)
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: double *GetCenter()
| GetCenter(self, center:[float, float, float]) -> None
| C++: void GetCenter(double center[3])
|
| Get the center of the bounding box. THIS METHOD IS NOT THREAD
| SAFE.
|
| GetDistinctCellTypes(...)
| GetDistinctCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetDistinctCellTypes(vtkCellTypes *types)
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset 5 triangles, 3 lines, and
| 100 hexahedra would result a list of three entries, corresponding
| to the types VTK_TRIANGLE, VTK_LINE, and VTK_HEXAHEDRON. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetGhostArray(int type) override;
|
| Returns the ghost array for the given type (point or cell). Takes
| advantage of the cache with the pointer to the array to save a
| string comparison.
|
| GetLength(...)
| GetLength(self) -> float
| C++: double GetLength()
|
| Return the length of the diagonal of the bounding box. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Return the squared length of the diagonal of the bounding box.
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetMaxSpatialDimension(...)
| GetMaxSpatialDimension(self) -> int
| C++: virtual int GetMaxSpatialDimension()
|
| Get the maximum/minimum spatial dimensionality of the data which
| is the maximum/minimum dimension of all cells.
|
| @warning This method MUST be overridden for performance reasons.
| Default implementation is very inefficient.
|
| GetMeshMTime(...)
| GetMeshMTime(self) -> int
| C++: virtual vtkMTimeType GetMeshMTime()
|
| Abstract method which return the mesh (geometry/topology)
| modification time. This time is different from the usual MTime
| which also takes into account the modification of data arrays.
| This function can be used to track the changes on the mesh
| separately from the data arrays (eg. static mesh over time with
| transient data). The default implementation returns the MTime. It
| is up to subclasses to provide a better approach.
|
| GetMinSpatialDimension(...)
| GetMinSpatialDimension(self) -> int
| C++: virtual int GetMinSpatialDimension()
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| GetPointData(...)
| GetPointData(self) -> vtkPointData
| C++: vtkPointData *GetPointData()
|
| Return a pointer to this dataset's point data. THIS METHOD IS
| THREAD SAFE
|
| GetPointGhostArray(...)
| GetPointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetPointGhostArray()
|
| Gets the array that defines the ghost type of each point. We
| cache the pointer to the array to save a lookup involving string
| comparisons
|
| GetScalarRange(...)
| GetScalarRange(self, range:[float, float]) -> None
| C++: virtual void GetScalarRange(double range[2])
| GetScalarRange(self) -> (float, float)
| C++: double *GetScalarRange()
|
| Convenience method to get the range of the first component (and
| only the first component) of any scalars in the data set. If the
| data has both point data and cell data, it returns the (min/max)
| range of combined point and cell data. If there are no point or
| cell scalars the method will return (0,1). Note: It might be
| necessary to call Update to create or refresh the scalars before
| calling this method. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| HasAnyBlankCells(...)
| HasAnyBlankCells(self) -> bool
| C++: virtual bool HasAnyBlankCells()
|
| Returns 1 if there are any blanking cells 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyBlankPoints(...)
| HasAnyBlankPoints(self) -> bool
| C++: virtual bool HasAnyBlankPoints()
|
| Returns 1 if there are any blanking points 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyGhostCells(...)
| HasAnyGhostCells(self) -> bool
| C++: bool HasAnyGhostCells()
|
| Returns 1 if there are any ghost cells 0 otherwise.
|
| HasAnyGhostPoints(...)
| HasAnyGhostPoints(self) -> bool
| C++: bool HasAnyGhostPoints()
|
| Returns 1 if there are any ghost points 0 otherwise.
|
| SetCellOrderAndRationalWeights(...)
| SetCellOrderAndRationalWeights(self, cellId:int,
| cell:vtkGenericCell) -> None
| C++: void SetCellOrderAndRationalWeights(vtkIdType cellId,
| vtkGenericCell *cell)
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| cell_ghost_array
| read-only, calls GetCellGhostArray
|
| length2
| read-only, calls GetLength2
|
| max_spatial_dimension
| read-only, calls GetMaxSpatialDimension
|
| mesh_m_time
| read-only, calls GetMeshMTime
|
| min_spatial_dimension
| read-only, calls GetMinSpatialDimension
|
| point_ghost_array
| read-only, calls GetPointGhostArray
|
| scalar_range
| read-only, calls GetScalarRange
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| CELL_DATA_FIELD = 2
|
| DATA_OBJECT_FIELD = 0
|
| FieldDataType = <class 'vtkmodules.vtkCommonDataModel.vtkDataSet.Field...
|
| POINT_DATA_FIELD = 1
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: virtual void Crop(const int *updateExtent)
|
| This method crops the data object (if necessary) so that the
| extent matches the update extent.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: virtual int GetExtentType()
|
| The ExtentType will be left as VTK_PIECES_EXTENT for data objects
| such as vtkPolyData and vtkUnstructuredGrid. The ExtentType will
| be changed to VTK_3D_EXTENT for data objects with 3D structure
| such as vtkImageData (and its subclass vtkStructuredPoints),
| vtkRectilinearGrid, and vtkStructuredGrid. The default is the
| have an extent in pieces, with only one piece (no streaming
| possible).
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| extent_type
| read-only, calls GetExtentType
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.PointSetCellOperationError
Python Library Documentation: class PointSetCellOperationError in module pyvista.core.errors class PointSetCellOperationError(PointSetNotSupported) | PointSetCellOperationError(message='Cell operations are not supported. PointSets contain no cells.') -> 'None' | | Requested filter or property is not supported by the PointSet class. | | Parameters | ---------- | message : str | Error message. | | Method resolution order: | PointSetCellOperationError | PointSetNotSupported | builtins.TypeError | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, message='Cell operations are not supported. PointSets contain no cells.') -> 'None' | Empty init. | | ---------------------------------------------------------------------- | Data descriptors inherited from PointSetNotSupported: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Static methods inherited from builtins.TypeError: | | __new__(*args, **kwargs) class method of builtins.TypeError | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.PointSetDimensionReductionError
Python Library Documentation: class PointSetDimensionReductionError in module pyvista.core.errors class PointSetDimensionReductionError(PointSetNotSupported) | PointSetDimensionReductionError(message='Slice and other dimension reducing filters are not supported on PointSets.') -> 'None' | | Requested filter or property is not supported by the PointSet class. | | Parameters | ---------- | message : str | Error message. | | Method resolution order: | PointSetDimensionReductionError | PointSetNotSupported | builtins.TypeError | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, message='Slice and other dimension reducing filters are not supported on PointSets.') -> 'None' | Empty init. | | ---------------------------------------------------------------------- | Data descriptors inherited from PointSetNotSupported: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Static methods inherited from builtins.TypeError: | | __new__(*args, **kwargs) class method of builtins.TypeError | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.PointSetNotSupported
Python Library Documentation: class PointSetNotSupported in module pyvista.core.errors class PointSetNotSupported(builtins.TypeError) | PointSetNotSupported(message='The requested operation is not supported for PointSets.') -> 'None' | | Requested filter or property is not supported by the PointSet class. | | Parameters | ---------- | message : str | Error message. | | Method resolution order: | PointSetNotSupported | builtins.TypeError | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, message='The requested operation is not supported for PointSets.') -> 'None' | Empty init. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Static methods inherited from builtins.TypeError: | | __new__(*args, **kwargs) class method of builtins.TypeError | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.PolyData
Python Library Documentation: class PolyData in module pyvista.core.pointset
class PolyData(_PointSet, pyvista.core.filters.poly_data.PolyDataFilters, vtkmodules.vtkCommonDataModel.vtkPolyData)
| PolyData(*args, **kwargs) -> '_T'
|
| Dataset consisting of surface geometry (e.g. vertices, lines, and polygons).
|
| The surface geometry is defined by its :attr:`~pyvista.DataSet.points` and four separate
| cell connectivity arrays:
|
| - :attr:`verts` for 0-dimensional :attr:`~pyvista.CellType.VERTEX` and
| :attr:`~pyvista.CellType.POLY_VERTEX` cells.
| - :attr:`lines` for 1-dimensional :attr:`~pyvista.CellType.LINE` and
| :attr:`~pyvista.CellType.POLY_LINE` cells.
| - :attr:`faces` for 2-dimensional :attr:`~pyvista.CellType.TRIANGLE`,
| :attr:`~pyvista.CellType.QUAD`, and :attr:`~pyvista.CellType.POLYGON` cells.
| - :attr:`strips` for 2-dimensional :attr:`~pyvista.CellType.TRIANGLE_STRIP` cells.
|
| Cell types can be mixed, and any combination of cell connectivity array(s) may be specified.
|
| :class:`~pyvista.PolyData` can be initialized in several ways:
|
| - Create an empty mesh
| - Initialize from a :vtk:`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 :attr:`verts` connectivity is
| populated by default, and each point is automatically associated with a single
| :attr:`~pyvista.CellType.VERTEX` to create a point cloud where :attr:`n_verts` equals
| :attr:`~pyvista.DataSet.n_points`.
|
| Parameters
| ----------
| var_inp : :vtk:`vtkPolyData`, str, sequence, optional
| Flexible input type. Can be a :vtk:`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``.
|
| faces : CellArrayLike, optional
| Connectivity of polygonal :attr:`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.
|
| lines : CellArrayLike, optional
| Connectivity of :attr:`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]``.
|
| strips : CellArrayLike optional
| Connectivity of triangle :attr:`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]``.
|
| deep : bool, 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_ext : str, 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_float : bool, 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.
|
| verts : CellArrayLike, optional
| The :attr:`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.
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| pyvista.PolyData.from_regular_faces
| pyvista.PolyData.from_irregular_faces
|
| Examples
| --------
| >>> 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 :vtk:`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')
|
| 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')
|
| Construct a mesh reusing the ``faces`` ``pv.CellArray`` from another
| mesh. The VTK methods ``GetPolys``, ``GetLines``, ``GetStrips``, and
| ``GetVerts`` return the underlying ``CellArray``s 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()
|
| See :ref:`create_poly_example` for more examples.
|
| Method resolution order:
| PolyData
| _PointSet
| pyvista.core.dataset.DataSet
| pyvista.core.filters.poly_data.PolyDataFilters
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkPolyData
| vtkmodules.vtkCommonDataModel.vtkPointSet
| vtkmodules.vtkCommonDataModel.vtkDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __and__(self, other_mesh)
| Compute boolean intersection of two meshes.
|
| __del__(self) -> 'None'
| Delete the object.
|
| __init__(self, var_inp: '_vtk.vtkPolyData | str | Path | MatrixLike[float] | None' = None, faces: 'CellArrayLike | None' = None, lines: 'CellArrayLike | None' = None, strips: 'CellArrayLike | None' = None, deep: 'bool' = False, force_ext: 'str | None' = None, force_float: 'bool' = True, verts: 'CellArrayLike | None' = None, *, validate: 'bool | _NestedMeshValidationFields' = False) -> 'None'
| Initialize the polydata.
|
| __isub__(self, cutting_mesh)
| Compute boolean difference of two meshes and update this mesh.
|
| __or__(self, other_mesh)
| Compute boolean union of two meshes.
|
| __repr__(self) -> 'str'
| Return the standard representation.
|
| __str__(self) -> 'str'
| Return the standard str representation.
|
| __sub__(self, cutting_mesh)
| Compute boolean difference of two meshes.
|
| obbTree = <functools.cached_property object>
| Return the obbTree of the polydata.
|
| An obbTree is an object to generate oriented bounding box (OBB)
| trees. An oriented bounding box is a bounding box that does not
| necessarily line up along coordinate axes. The OBB tree is a
| hierarchical tree structure of such boxes, where deeper levels of OBB
| confine smaller regions of space.
|
| .. warning::
|
| This property is expensive to compute and is therefore cached. If the mesh's
| geometry is modified, the obb tree will no longer be valid.
|
| save(self, filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, recompute_normals: 'bool' = True, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Write a surface mesh to disk.
|
| Written file may be an ASCII or binary ply, stl, or vtk mesh
| file.
|
| Parameters
| ----------
| filename : str, Path
| Filename of mesh to be written. File type is inferred from
| the extension of the filename unless overridden with
| ftype. Can be one of many of the supported the following
| types (``'.ply'``, ``'.vtp'``, ``'.stl'``, ``'.vtk``, ``'.geo'``,
| ``'.obj'``, ``'.iv'``).
|
| binary : bool, default: True
| Writes the file as binary when ``True`` and ASCII when ``False``.
|
| texture : str, numpy.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'`` if the array
| contains an alpha channel (i.e. 4 component array), or
| as ``'RGB'`` if the array is just a 3 component array.
|
| .. note::
| This feature is only available when saving PLY files.
|
| recompute_normals : bool, default: True
| When ``True``, if ply or stl format is chosen, the face normals
| are computed in place to ensure the mesh is properly saved.
| Set this to ``False`` to save instead the already existing normal
| array in the PolyData.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. When
| the target extension dispatches to a built-in VTK writer or
| to the pickle path, passing any extra keyword arguments
| raises :class:`TypeError`.
|
| .. versionadded:: 0.48
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| Examples
| --------
| Save a mesh as a STL.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.save('my_mesh.stl') # doctest:+SKIP
|
| Save a mesh as a PLY.
|
| >>> sphere = pv.Sphere()
| >>> sphere.save('my_mesh.ply') # doctest:+SKIP
|
| Save a mesh as a PLY with a texture array. Here we also
| create a simple RGB array representing the texture.
|
| >>> import numpy as np
| >>> sphere = pv.Sphere()
| >>> texture = np.zeros((sphere.n_points, 3), np.uint8)
| >>> # Just the green channel is set as a repeatedly
| >>> # decreasing value
| >>> texture[:, 1] = np.arange(sphere.n_points)[::-1]
| >>> sphere.point_data['my_texture'] = texture
| >>> sphere.save('my_mesh.ply', texture='my_texture') # doctest:+SKIP
|
| Alternatively, provide just the texture array. This will be
| written to the file as ``'RGB'`` since it does not contain an
| alpha channel.
|
| >>> sphere.save('my_mesh.ply', texture=texture) # doctest:+SKIP
|
| Save a mesh as a VTK file.
|
| >>> sphere = pv.Sphere()
| >>> sphere.save('my_mesh.vtk') # doctest:+SKIP
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_irregular_faces(points: 'MatrixLike[float]', faces: 'Sequence[VectorLike[int]]')
| Alternate `pyvista.PolyData` convenience constructor from point and ragged face arrays.
|
| Parameters
| ----------
| points : MatrixLike[float]
| A (n_points, 3) array of points.
|
| faces : Sequence[VectorLike[int]]
| A sequence of face vectors containing point indices.
|
| Returns
| -------
| pyvista.PolyData
| The newly constructed mesh.
|
| See Also
| --------
| pyvista.PolyData.from_regular_faces
|
| Examples
| --------
| Construct a pyramid from five points and five faces
|
| >>> import pyvista as pv
| >>> points = [
| ... (1, 1, 0),
| ... (-1, 1, 0),
| ... (-1, -1, 0),
| ... (1, -1, 0),
| ... (0, 0, 1.61),
| ... ]
| >>> faces = [
| ... (0, 1, 2, 3),
| ... (0, 3, 4),
| ... (0, 4, 1),
| ... (3, 2, 4),
| ... (2, 1, 4),
| ... ]
| >>> pyramid = pv.PolyData.from_irregular_faces(points, faces)
| >>> pyramid.plot()
|
| from_regular_faces(points: 'MatrixLike[float]', faces: 'MatrixLike[int]', deep: 'bool' = False)
| Alternate `pyvista.PolyData` convenience constructor from point and regular face arrays.
|
| Parameters
| ----------
| points : MatrixLike[float]
| A (n_points, 3) array of points.
|
| faces : MatrixLike[int]
| A (n_faces, face_size) array of face indices. For a triangle mesh, ``face_size = 3``.
|
| deep : bool, default: False
| Whether to deep copy the faces array into :vtk:`vtkCellArray` connectivity data.
|
| Returns
| -------
| pyvista.PolyData
| The newly constructed mesh.
|
| See Also
| --------
| pyvista.PolyData.from_irregular_faces
|
| Examples
| --------
| Construct a tetrahedron from four triangles
|
| >>> import pyvista as pv
| >>> points = [[1.0, 1, 1], [-1, 1, -1], [1, -1, -1], [-1, -1, 1]]
| >>> faces = [[0, 1, 2], [1, 3, 2], [0, 2, 3], [0, 3, 1]]
| >>> tetra = pv.PolyData.from_regular_faces(points, faces)
| >>> tetra.plot()
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| cell_normals
| Return the cell normals.
|
| The active cell normals are returned if they exist. Otherwise, they
| are computed with :func:`~pyvista.PolyDataFilters.compute_normals`
| using the default options.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Array of cell normals.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.cell_normals
| pyvista_ndarray([[ 0.05413816, 0.00569015, 0.9985172 ],
| [ 0.05177207, 0.01682176, 0.9985172 ],
| [ 0.04714328, 0.02721819, 0.9985172 ],
| ...,
| [ 0.26742265, -0.02810723, -0.96316934],
| [ 0.1617585 , -0.01700151, -0.9866839 ],
| [ 0.1617585 , -0.01700151, -0.9866839 ]],
| shape=(1680, 3), dtype=float32)
|
| face_normals
| Return the cell normals.
|
| Alias to :func:`PolyData.cell_normals`.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Array of face normals.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.face_normals
| pyvista_ndarray([[ 0.05413816, 0.00569015, 0.9985172 ],
| [ 0.05177207, 0.01682176, 0.9985172 ],
| [ 0.04714328, 0.02721819, 0.9985172 ],
| ...,
| [ 0.26742265, -0.02810723, -0.96316934],
| [ 0.1617585 , -0.01700151, -0.9866839 ],
| [ 0.1617585 , -0.01700151, -0.9866839 ]],
| shape=(1680, 3), dtype=float32)
|
| is_all_triangles
| Return if all the faces of the :class:`pyvista.PolyData` are triangles.
|
| Returns
| -------
| bool
| ``True`` if all the faces of the :class:`pyvista.PolyData`
| are triangles and does not contain any vertices or lines.
|
| Examples
| --------
| Show a mesh from :func:`pyvista.Plane` is not composed of all
| triangles.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.is_all_triangles
| False
|
| Show that the mesh from :func:`pyvista.Sphere` contains only
| triangles.
|
| >>> sphere = pv.Sphere()
| >>> sphere.is_all_triangles
| True
|
| is_manifold
| Return if the mesh is manifold (no open edges).
|
| Examples
| --------
| Show a sphere is manifold.
|
| >>> import pyvista as pv
| >>> pv.Sphere().is_manifold
| True
|
| Show a plane is not manifold.
|
| >>> pv.Plane().is_manifold
| False
|
| n_faces
| Return the number of polygonal faces.
|
| This is the total number of :attr:`~pyvista.CellType.TRIANGLE`,
| :attr:`~pyvista.CellType.QUAD`, and :attr:`~pyvista.CellType.POLYGON` cells defined in
| the :attr:`faces` connectivity array.
|
| See Also
| --------
| faces
| n_verts, n_lines, n_strips
| Number of cells in other connectivity arrays.
| pyvista.DataSet.n_cells, pyvista.DataSet.n_points
| Number of total cells and points in this mesh.
|
| Examples
| --------
| Create a mesh with one face and one line
|
| >>> import pyvista as pv
| >>> mesh = pv.PolyData(
| ... [(0.0, 0, 0), (1, 0, 0), (0, 1, 0)],
| ... faces=[3, 0, 1, 2],
| ... lines=[2, 0, 1],
| ... )
| >>> mesh.n_cells, mesh.n_faces, mesh.n_lines
| (2, 1, 1)
|
| n_faces_strict
| Return the number of polygonal faces.
|
| .. deprecated:: 0.49
| Use :attr:`n_faces` instead. As of v0.49, :attr:`n_faces` returns the
| number of polygonal faces, identical to ``n_faces_strict``.
|
| n_lines
| Return the number of line cells.
|
| This is the total number of :attr:`~pyvista.CellType.LINE` and
| :attr:`~pyvista.CellType.POLY_LINE` cells defined in the :attr:`lines` connectivity array.
|
| See Also
| --------
| lines
| n_verts, n_faces, n_strips
| Number of cells in other connectivity arrays.
| pyvista.DataSet.n_cells, pyvista.DataSet.n_points
| Number of total cells and points in this mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Line()
| >>> mesh.n_lines, mesh.n_cells
| (1, 1)
|
| n_open_edges
| Return the number of open edges on this mesh.
|
| Examples
| --------
| Return the number of open edges on a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.n_open_edges
| 0
|
| Return the number of open edges on a plane.
|
| >>> plane = pv.Plane(i_resolution=1, j_resolution=1)
| >>> plane.n_open_edges
| 4
|
| n_strips
| Return the number of triangle strips.
|
| This is the total number of :attr:`~pyvista.CellType.TRIANGLE_STRIP` cells defined in the
| :attr:`strips` connectivity array.
|
| See Also
| --------
| strips
| n_verts, n_lines, n_faces
| Number of cells in other connectivity arrays.
| pyvista.DataSet.n_cells, pyvista.DataSet.n_points
| Number of total cells and points in this mesh.
|
| Examples
| --------
| Create a simple mesh with one triangle strip and return the
| number of triangles.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> vertices = np.array([[1.0, 0.0, 0.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])
| >>> strip = np.array([3, 0, 1, 2])
| >>> mesh = pv.PolyData(vertices, strips=strip)
| >>> mesh.n_strips, mesh.n_cells
| (1, 1)
|
| n_verts
| Return the number of vertex cells.
|
| This is the total number of :attr:`~pyvista.CellType.VERTEX` and
| :attr:`~pyvista.CellType.POLY_VERTEX` cells defined in the :attr:`verts` connectivity
| array.
|
| .. note::
| The number of vertices is separate and distinct from :attr:`~pyvista.DataSet.n_points`,
| as it's possible for :class:`~pyvista.PolyData` to have :attr:`~pyvista.DataSet.points`
| but no :attr:`verts`.
|
| See Also
| --------
| verts
| n_lines, n_faces, n_strips
| Number of cells in other connectivity arrays.
| pyvista.DataSet.n_cells, pyvista.DataSet.n_points
| Number of total cells and points in this mesh.
|
| Examples
| --------
| Create a simple mesh containing just two points and return the
| number of vertices and cells. By default, when constructing a PolyData with points but no
| cells, vertices are automatically created, one per point.
|
| >>> import pyvista as pv
| >>> mesh = pv.PolyData([[1.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.n_points, mesh.n_verts, mesh.n_cells
| (2, 2, 2)
|
| If any other cells are specified, these vertices are not created.
|
| >>> import pyvista as pv
| >>> mesh = pv.PolyData([[1.0, 0.0, 0.0], [1.0, 1.0, 1.0]], lines=[2, 0, 1])
| >>> mesh.n_points, mesh.n_verts, mesh.n_cells
| (2, 0, 1)
|
| point_normals
| Return the point normals.
|
| The active point normals are returned if they exist. Otherwise, they
| are computed with :func:`~pyvista.PolyDataFilters.compute_normals`
| using the default options.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Array of point normals.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.point_normals
| pyvista_ndarray([[ 0. , 0. , 1. ],
| [ 0. , 0. , -1. ],
| [ 0.10811902, 0. , 0.99413794],
| ...,
| [ 0.31232402, -0.06638652, -0.9476532 ],
| [ 0.21027282, -0.04469487, -0.97662055],
| [ 0.10575636, -0.02247921, -0.99413794]],
| shape=(842, 3), dtype=float32)
|
| volume
| Return the approximate volume of the dataset.
|
| This will throw a VTK error/warning if not a closed surface.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.volume
| 0.5183
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| faces
| Return the polygonal faces padded connectivity array.
|
| Like all padded VTK connectivity arrays, the array is structured as::
|
| [n0, p0_0, p0_1, ..., p0_n, n1, p1_0, p1_1, ..., p1_n, ...]
|
| where ``n0`` is the number of points in face 0, and ``pX_Y`` is the
| Y'th point in face X.
|
| Faces can be :attr:`~pyvista.CellType.TRIANGLE`, :attr:`~pyvista.CellType.QUAD`,
| or :attr:`~pyvista.CellType.POLYGON` cells.
|
| For example, a triangle and a quadrilateral might be represented as::
|
| [3, 0, 1, 2, 4, 0, 1, 3, 4]
|
| Where the two individual faces are ``[3, 0, 1, 2]`` and ``[4, 0, 1, 3, 4]``.
|
| Faces can also be set by assigning a :class:`~pyvista.CellArray` object
| instead of an array.
|
| Returns
| -------
| numpy.ndarray
| Array of face connectivity.
|
| See Also
| --------
| n_faces
| verts, lines, strips
| Padded connectivity arrays for other :class:`~pyvista.PolyData` cell types.
| pyvista.PolyData.regular_faces, pyvista.PolyData.irregular_faces
| Initialize :class:`~pyvista.PolyData` from faces.
|
| Notes
| -----
| The array returned cannot be modified in place and will raise a
| ``ValueError`` if attempted.
|
| You can, however, set the faces directly. See the example.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> plane = pv.Plane(i_resolution=2, j_resolution=2)
| >>> plane.faces
| array([4, 0, 1, 4, 3, 4, 1, 2, 5, 4, 4, 3, 4, 7, 6, 4, 4, 5, 8, 7])
|
| Note how the faces contain a "padding" indicating the number
| of points per face:
|
| >>> plane.faces.reshape(-1, 5)
| array([[4, 0, 1, 4, 3],
| [4, 1, 2, 5, 4],
| [4, 3, 4, 7, 6],
| [4, 4, 5, 8, 7]])
|
| Set the faces directly. The following example creates a simple plane
| with a single square faces and modifies it to have two triangles
| instead.
|
| >>> mesh = pv.Plane(i_resolution=1, j_resolution=1)
| >>> mesh.faces = [3, 0, 1, 2, 3, 3, 2, 1]
| >>> mesh.faces
| array([3, 0, 1, 2, 3, 3, 2, 1])
|
| irregular_faces
| Return a tuple of face arrays.
|
| Returns
| -------
| tuple[numpy.ndarray]
| Tuple of length n_faces where each element is an array of point
| indices for points in that face.
|
| See Also
| --------
| pyvista.PolyData.faces
| pyvista.PolyData.regular_faces
|
| Examples
| --------
| Get the face arrays of the five faces of a pyramid.
|
| >>> import pyvista as pv
| >>> pyramid = pv.Pyramid().extract_surface(algorithm=None)
| >>> pyramid.irregular_faces # doctest: +NORMALIZE_WHITESPACE
| (array([0, 4, 3], dtype=int32),
| array([0, 1, 4], dtype=int32),
| array([0, 3, 2, 1], dtype=int32),
| array([1, 2, 4], dtype=int32),
| array([2, 3, 4], dtype=int32))
|
| lines
| Return the lines connectivity array.
|
| Like all padded VTK connectivity arrays, the array is structured as::
|
| [n0, p0_0, p0_1, ..., p0_n, n1, p1_0, p1_1, ..., p1_n, ...]
|
| where ``n0`` is the number of points in line 0, and ``pX_Y`` is the
| Y'th point in line X.
|
| Lines can be a single :attr:`~pyvista.CellType.LINE` cell with connectivity
| to two points, or a :attr:`~pyvista.CellType.POLY_LINE` with connectivity
| to any number of points.
|
| For example, a single line and poly-line with five points might be represented as::
|
| [2, 0, 1, 5, 3, 2, 4, 6, 5]
|
| Where the two separate line cells are ``[2, 0, 1]`` and ``[5, 3, 2, 4, 6, 5]``.
|
| Lines can also be set by assigning a :class:`~pyvista.CellArray`.
|
| See Also
| --------
| n_lines
| verts, faces, strips
| Padded connectivity arrays for other :class:`~pyvista.PolyData` cell types.
|
| Examples
| --------
| Return the lines from a spline.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.random.default_rng().random((3, 3))
| >>> spline = pv.Spline(points, 10)
| >>> spline.lines
| array([10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| regular_faces
| Return a face array of point indices when all faces have the same size.
|
| Returns
| -------
| numpy.ndarray
| Array of face indices with shape (n_faces, face_size).
|
| See Also
| --------
| pyvista.PolyData.faces
|
| Raises
| ------
| ValueError
| If the mesh's faces are irregular.
|
| Examples
| --------
| Get the regular face array of a plane with 2x2 arrangement of cells
| as a 4x4 array.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane(i_resolution=2, j_resolution=2)
| >>> plane.regular_faces
| array([[0, 1, 4, 3],
| [1, 2, 5, 4],
| [3, 4, 7, 6],
| [4, 5, 8, 7]])
|
| strips
| Return or set the strips padded connectivity array.
|
| Like all padded VTK connectivity arrays, the array is structured as::
|
| [n0, p0_0, p0_1, ..., p0_n, n1, p1_0, p1_1, ..., p1_n, ...]
|
| where ``n0`` is the number of points in strip 0, and ``pX_Y`` is the
| Y'th point in strip X.
|
| Only the connectivity of :attr:`~pyvista.CellType.TRIANGLE_STRIP` cells is stored in this
| array.
|
| For example, two strips with one and two triangles, respectively, might look like::
|
| [3, 0, 1, 2, 4, 3, 4, 5, 6]
|
| Where the individual strips are ``[3, 0, 1, 2]`` and ``[4, 3, 4, 5, 6]``.
|
| Returns
| -------
| numpy.ndarray
| Array of strip indices.
|
| See Also
| --------
| n_strips
| verts, lines, faces
| Padded connectivity arrays for other :class:`~pyvista.PolyData` cell types.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> polygon = pv.Rectangle()
| >>> extruded = polygon.extrude((0, 0, 1), capping=False)
| >>> extruded.strips
| array([4, 0, 1, 4, 5, 4, 1, 2, 5, 6, 4, 2, 3, 6, 7, 4, 3, 0, 7, 4])
| >>> extruded.n_strips
| 4
|
| verts
| Return or set the vertex padded connectivity array.
|
| Like all padded VTK connectivity arrays, the array is structured as::
|
| [n0, p0_0, p0_1, ..., p0_n, n1, p1_0, p1_1, ..., p1_n, ...]
|
| where ``n0`` is the number of points in vertex 0, and ``pX_Y`` is the
| Y'th point in vertex X.
|
| Vertices can be a single :attr:`~pyvista.CellType.VERTEX` cell with connectivity
| to a single point, or a :attr:`~pyvista.CellType.POLY_VERTEX` with connectivity
| to multiple points.
|
| For example, a single vertex and poly-vertex with five points might be represented as::
|
| [1, 0, 5, 3, 2, 4, 1, 5]
|
| Where the two separate vertex cells are ``[1, 0]`` and ``[5, 3, 2, 4, 1, 5]``.
|
| See Also
| --------
| n_verts
| lines, faces, strips
| Padded connectivity arrays for other :class:`~pyvista.PolyData` cell types.
|
| Returns
| -------
| numpy.ndarray
| Array of vertex cell connectivity.
|
| Examples
| --------
| Create a point cloud polydata and return the vertex cells.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(seed=0)
| >>> points = rng.random((5, 3))
| >>> pdata = pv.PolyData(points)
| >>> pdata.verts
| array([1, 0, 1, 1, 1, 2, 1, 3, 1, 4])
|
| Set vertex cells. Note how the mesh plots both the surface
| mesh and the additional vertices in a single plot.
|
| >>> mesh = pv.Plane(i_resolution=3, j_resolution=3)
| >>> mesh.verts = np.vstack(
| ... (
| ... np.ones(mesh.n_points, dtype=np.int64),
| ... np.arange(mesh.n_points),
| ... )
| ... ).T
| >>> mesh.plot(
| ... color='lightblue',
| ... render_points_as_spheres=True,
| ... point_size=60,
| ... )
|
| Vertex cells can also be set to a ``CellArray``. The following
| ``verts`` assignment is equivalent to the one above.
|
| >>> mesh.verts = pv.CellArray.from_regular_cells(
| ... np.arange(mesh.n_points).reshape((-1, 1))
| ... )
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| ----------------------------------------------------------------------
| Methods inherited from _PointSet:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| center_of_mass(self, scalars_weight: 'bool' = False) -> 'NumpyArray[float]'
| Return the coordinates for the center of mass of the mesh.
|
| Parameters
| ----------
| scalars_weight : bool, default: False
| Flag for using the mesh scalars as weights.
|
| Returns
| -------
| numpy.ndarray
| Coordinates for the center of mass.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 1, 1))
| >>> mesh.center_of_mass()
| array([1., 1., 1.])
|
| points_to_double(self) -> 'Self'
| Convert the points datatype to double precision.
|
| Returns
| -------
| pyvista.PointSet
| Pointset with points in double precision.
|
| Notes
| -----
| This operates in place.
|
| Examples
| --------
| Create a mesh that has points of the type ``float32`` and
| convert the points to ``float64``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.points.dtype
| dtype('float32')
| >>> _ = mesh.points_to_double()
| >>> mesh.points.dtype
| dtype('float64')
|
| remove_cells(self, ind: 'VectorLike[bool] | VectorLike[int]', inplace: 'bool' = False) -> '_PointSet'
| Remove cells.
|
| Parameters
| ----------
| ind : VectorLike[int] | VectorLike[bool]
| Cell indices to be removed. The array can also be a
| boolean array of the same size as the number of cells.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| Returns
| -------
| pyvista.DataSet
| Same type as the input, but with the specified cells
| removed.
|
| See Also
| --------
| :ref:`ghost_cells_example`
|
| Examples
| --------
| Remove 20 cells from an unstructured grid.
|
| >>> from pyvista import examples
| >>> import pyvista as pv
| >>> hex_mesh = pv.read(examples.hexbeamfile)
| >>> removed = hex_mesh.remove_cells(range(10, 20))
| >>> removed.plot(color='lightblue', show_edges=True, line_width=3)
|
| shallow_copy(self, to_copy: 'DataSet') -> 'None'
| Create a shallow copy from a different dataset into this one.
|
| This method mutates this dataset and returns ``None``.
|
| Parameters
| ----------
| to_copy : pyvista.DataSet
| Data object to perform the shallow copy from.
|
| translate(self: 'Self', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False)
| Translate the mesh.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats of cartesian values to translate the mesh with.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed. This is
| only valid when not updating in place.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PointSet
| Translated pointset.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=True)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.poly_data.PolyDataFilters:
|
| __add__(self: 'PolyData', dataset)
| Merge these two meshes.
|
| __iadd__(self: 'PolyData', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``dataset`` is also a :class:`PolyData`.
| Otherwise we have to return a :class:`pyvista.UnstructuredGrid`,
| so the in-place merge attempt will raise.
|
| append_polydata(self, *meshes, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Append one or more PolyData into this one.
|
| Under the hood, the VTK :vtk:`vtkAppendPolyData`
| filter is used to perform the append operation.
|
| .. versionadded:: 0.40.0
|
| .. note::
| As stated in the VTK documentation of :vtk:`vtkAppendPolyData`,
| point and cell data are added to the output PolyData **only** if they
| are present across **all** input PolyData.
|
| .. seealso::
| :func:`pyvista.PolyDataFilters.merge`
|
| Parameters
| ----------
| *meshes : list[pyvista.PolyData]
| The PolyData(s) to append with the current one.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Appended PolyData(s).
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sp0 = pv.Sphere()
| >>> sp1 = sp0.translate((1, 0, 0))
| >>> appended = sp0.append_polydata(sp1)
| >>> appended.plot()
|
| Append more than one PolyData.
|
| >>> sp2 = sp0.translate((-1, 0, 0))
| >>> appended = sp0.append_polydata(sp1, sp2)
| >>> appended.plot()
|
| boolean_difference(self, other_mesh, tolerance=1e-05, progress_bar: 'bool' = False)
| Perform a boolean difference operation between two meshes.
|
| Essentially, boolean union, difference, and intersection are
| all the same operation. Just different parts of the objects
| are kept at the end.
|
| The difference of two manifold meshes ``A`` and ``B`` is the
| volume of the mesh in ``A`` not belonging to ``B``.
|
| .. note::
| If your boolean operations don't react the way you think they
| should (i.e. the wrong parts disappear), one of your meshes
| probably has its normals pointing inward. Use
| :func:`PolyDataFilters.plot_normals` to visualize the
| normals.
|
| .. note::
| Both meshes must be composed of all triangles. Check with
| :attr:`PolyData.is_all_triangles` and convert with
| :func:`PolyDataFilters.triangulate`.
|
| .. versionchanged:: 0.32.0
| Behavior changed to match default VTK behavior.
|
| Parameters
| ----------
| other_mesh : pyvista.PolyData
| Mesh operating on the source mesh.
|
| tolerance : float, default: 1e-5
| Tolerance used to determine when a point's absolute
| distance is considered to be zero.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The result of the boolean operation.
|
| Examples
| --------
| Demonstrate a boolean difference with two spheres. Note how
| the final mesh only includes ``sphere_a``.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> result = sphere_a - sphere_b
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere_a, color='r', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(sphere_b, color='b', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(result, color='lightblue')
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| boolean_intersection(self, other_mesh, tolerance=1e-05, progress_bar: 'bool' = False)
| Perform a boolean intersection operation on two meshes.
|
| Essentially, boolean union, difference, and intersection are
| all the same operation. Just different parts of the objects
| are kept at the end.
|
| The intersection of two manifold meshes ``A`` and ``B`` is the mesh
| which is the volume of ``A`` that is also in ``B``.
|
| .. note::
| If your boolean operations don't react the way you think they
| should (i.e. the wrong parts disappear), one of your meshes
| probably has its normals pointing inward. Use
| :func:`PolyDataFilters.plot_normals` to visualize the
| normals.
|
| .. note::
| This method returns the "volume" intersection between two
| meshes whereas the :func:`PolyDataFilters.intersection`
| filter returns the surface intersection between two meshes
| (which often resolves as a line).
|
|
| .. note::
| Both meshes must be composed of all triangles. Check with
| :attr:`PolyData.is_all_triangles` and convert with
| :func:`PolyDataFilters.triangulate`.
|
| .. versionadded:: 0.32.0
|
| .. versionchanged:: 0.45.0
| Define ``&`` operator to perform boolean intersection.
|
| Parameters
| ----------
| other_mesh : pyvista.PolyData
| Mesh operating on the source mesh.
|
| tolerance : float, default: 1e-5
| Tolerance used to determine when a point's absolute
| distance is considered to be zero.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The result of the boolean operation.
|
| Examples
| --------
| Demonstrate a boolean intersection with two spheres. Note how
| the final mesh only includes the intersection of the two.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> result = sphere_a & sphere_b
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere_a, color='r', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(sphere_b, color='b', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(result, color='lightblue')
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| boolean_union(self, other_mesh, tolerance=1e-05, progress_bar: 'bool' = False)
| Perform a boolean union operation on two meshes.
|
| Essentially, boolean union, difference, and intersection are
| all the same operation. Just different parts of the objects
| are kept at the end.
|
| The union of two manifold meshes ``A`` and ``B`` is the mesh
| which is in ``A``, in ``B``, or in both ``A`` and ``B``.
|
| .. note::
| If your boolean operations don't react the way you think they
| should (i.e. the wrong parts disappear), one of your meshes
| probably has its normals pointing inward. Use
| :func:`PolyDataFilters.plot_normals` to visualize the
| normals.
|
| .. note::
| The behavior of this filter varies from the
| :func:`PolyDataFilters.merge` filter. This filter attempts
| to create a manifold mesh and will not include internal
| surfaces when two meshes overlap.
|
| .. note::
| Both meshes must be composed of all triangles. Check with
| :attr:`PolyData.is_all_triangles` and convert with
| :func:`PolyDataFilters.triangulate`.
|
| .. versionchanged:: 0.32.0
| Behavior changed to match default VTK behavior.
|
| .. versionchanged:: 0.45.0
| Define ``|`` operator to perform boolean union.
|
| Parameters
| ----------
| other_mesh : pyvista.PolyData
| Mesh operating on the source mesh.
|
| tolerance : float, tolerance: 1e-5
| Tolerance used to determine when a point's absolute
| distance is considered to be zero.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The result of the boolean operation.
|
| Examples
| --------
| Demonstrate a boolean union with two spheres. Note how the
| final mesh includes both spheres.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> result = sphere_a | sphere_b
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere_a, color='r', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(sphere_b, color='b', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(result, color='lightblue')
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| clean(self, point_merging: 'bool' = True, tolerance=None, lines_to_points: 'bool' = True, polys_to_lines: 'bool' = True, strips_to_polys: 'bool' = True, inplace: 'bool' = False, absolute: 'bool' = True, progress_bar: 'bool' = False, **kwargs)
| Clean the mesh.
|
| This merges duplicate points, removes unused points, and/or
| removes degenerate cells.
|
| Parameters
| ----------
| point_merging : bool, optional
| Enables point merging. ``True`` by default.
|
| tolerance : float, optional
| Set merging tolerance. When enabled merging is set to
| absolute distance. If ``absolute`` is ``False``, then the
| merging tolerance is a fraction of the bounding box
| length. The alias ``merge_tol`` is also excepted.
|
| lines_to_points : bool, optional
| Enable or disable the conversion of degenerate lines to
| points. Enabled by default.
|
| polys_to_lines : bool, optional
| Enable or disable the conversion of degenerate polys to
| lines. Enabled by default.
|
| strips_to_polys : bool, optional
| Enable or disable the conversion of degenerate strips to
| polys.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| absolute : bool, optional
| Control if ``tolerance`` is an absolute distance or a
| fraction.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts for ``merge_tol`` to replace the ``tolerance``
| keyword argument. This may be deprecated in future.
|
| Returns
| -------
| pyvista.PolyData
| Cleaned mesh.
|
| See Also
| --------
| remove_unused_points
| Strictly remove unused points `without` merging points.
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Create a mesh with a degenerate face and then clean it,
| removing the degenerate face
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array([[0, 0, 0], [0, 1, 0], [1, 0, 0]], dtype=np.float32)
| >>> faces = np.array([3, 0, 1, 2, 3, 0, 2, 2])
| >>> mesh = pv.PolyData(points, faces)
| >>> mout = mesh.clean()
| >>> mout.faces # doctest:+SKIP
| array([3, 0, 1, 2])
|
| clip_closed_surface(self: 'PolyData', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, tolerance=1e-06, inplace: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a closed polydata surface with a plane.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| This currently only supports one plane but could be
| implemented to handle a plane collection.
|
| It will produce a new closed surface by creating new polygonal
| faces where the input data was clipped.
|
| Non-manifold surfaces should not be used as input for this
| filter. The input surface should have no open edges, and must
| not have any edges that are shared by more than two faces. In
| addition, the input surface should not self-intersect, meaning
| that the faces of the surface should only touch at their
| edges.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| tolerance : float, optional
| The tolerance for creating new points while clipping. If
| the tolerance is too small, then degenerate triangles
| might be produced.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| The clipped mesh.
|
| Examples
| --------
| Clip a sphere in the X direction centered at the origin. This
| will leave behind half a sphere in the positive X direction.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> clipped_mesh = sphere.clip_closed_surface('-z')
| >>> clipped_mesh.plot(show_edges=True, line_width=3)
|
| Clip the sphere at the XY plane and leave behind half the
| sphere in the positive Z direction. Shift the clip upwards to
| leave a smaller mesh behind.
|
| >>> clipped_mesh = sphere.clip_closed_surface('z', origin=[0, 0, 0.3])
| >>> clipped_mesh.plot(show_edges=True, line_width=3)
|
| See :ref:`clip_closed_surface_example` for more examples using this filter.
|
| collision(self, other_mesh, contact_mode=0, box_tolerance=0.001, cell_tolerance=0.0, n_cells_per_node=2, generate_scalars: 'bool' = False, progress_bar: 'bool' = False)
| Perform collision determination between two polyhedral surfaces.
|
| If ``collision_mode`` is set to all contacts, the output will
| be lines of contact. If ``collision_mode`` is first contact or half
| contacts then the Contacts output will be vertices.
|
| .. warning::
| Currently only triangles are processed. Use
| :func:`PolyDataFilters.triangulate` to convert any strips
| or polygons to triangles. Otherwise, the mesh will be
| converted for you within this method.
|
| Parameters
| ----------
| other_mesh : pyvista.DataSet
| Other mesh to test collision with. If the other mesh is
| not a surface, its external surface will be extracted and
| triangulated.
|
| contact_mode : int, default: 0
| Contact mode. One of the following:
|
| * 0 - All contacts. Find all the contacting cell pairs
| with two points per collision
| * 1 - First contact. Quickly find the first contact point.
| * 2 - Half contacts. Find all the contacting cell pairs
| with one point per collision.
|
| box_tolerance : float, default: 0.001
| Oriented bounding box (OBB) tree tolerance in world coordinates.
|
| cell_tolerance : float, default: 0.0
| Cell tolerance (squared value).
|
| n_cells_per_node : int, default: 2
| Number of cells in each OBB.
|
| generate_scalars : bool, default: False
| Flag to visualize the contact cells. If ``True``, the
| contacting cells will be colored from red through blue,
| with collisions first determined colored red. This array
| is stored as ``"collision_rgba"``.
|
| .. note::
| This will remove any other cell arrays in the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing collisions in the ``field_data``
| attribute named ``"ContactCells"``. Array only exists
| when there are collisions.
|
| int
| Number of collisions.
|
| Notes
| -----
| Due to the nature of the :vtk:`vtkCollisionDetectionFilter`,
| repeated uses of this method will be slower that using the
| :vtk:`vtkCollisionDetectionFilter` directly. The first
| update of the filter creates two instances of :vtk:`vtkOBBTree`,
| which can be subsequently updated by modifying the transform or
| matrix of the input meshes.
|
| This method assumes no transform and is easier to use for
| single collision tests, but it is recommended to use a
| combination of ``pyvista`` and ``vtk`` for rapidly computing
| repeated collisions. See the `Collision Detection Example
| <https://kitware.github.io/vtk-examples/site/Python/Visualization/CollisionDetection/>`_
|
| Examples
| --------
| Compute the collision between a sphere and the back faces of a
| cube and output the cell indices of the first 10 collisions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere(radius=0.5)
| >>> mesh_b = pv.Cube(center=(0.5, 0.5, 0.5)).extract_cells([0, 2, 4])
| >>> collision, ncol = mesh_a.collision(mesh_b, cell_tolerance=1)
| >>> collision['ContactCells'][:10]
| pyvista_ndarray([464, 0, 0, 29, 29, 27, 27, 28, 28, 23])
|
| Plot the collisions by creating a collision mask with the
| ``"ContactCells"`` field data. Cells with a collision are
| colored red.
|
| >>> scalars = np.zeros(collision.n_cells, dtype=bool)
| >>> scalars[collision.field_data['ContactCells']] = True
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... collision,
| ... scalars=scalars,
| ... show_scalar_bar=False,
| ... cmap='bwr',
| ... )
| >>> _ = pl.add_mesh(
| ... mesh_b,
| ... color='lightblue',
| ... line_width=5,
| ... opacity=0.7,
| ... show_edges=True,
| ... )
| >>> pl.show()
|
| Alternatively, simply plot the collisions using the default
| ``'collision_rgba'`` array after enabling ``generate_scalars``.
|
| >>> collision, ncol = mesh_a.collision(
| ... mesh_b, cell_tolerance=1, generate_scalars=True
| ... )
| >>> collision.plot()
|
| See :ref:`collision_example` for more examples using this filter.
|
| compute_arc_length(self, progress_bar: 'bool' = False)
| Compute the arc length over the length of the probed line.
|
| It adds a new point-data array named ``"arc_length"`` with the
| computed arc length for each of the polylines in the
| input. For all other cell types, the arc length is set to 0.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| float
| Arc length of the length of the probed line.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> path = sphere.geodesic(0, 100)
| >>> length = path.compute_arc_length()['arc_length'][-1]
| >>> f'Length is {length:.3f}'
| 'Length is 0.812'
|
| This is identical to the geodesic_distance.
|
| >>> length = sphere.geodesic_distance(0, 100)
| >>> f'Length is {length:.3f}'
| 'Length is 0.812'
|
| You can also plot the arc_length.
|
| >>> arc = path.compute_arc_length()
| >>> arc.plot(scalars='arc_length')
|
| compute_normals(self, cell_normals: 'bool' = True, point_normals: 'bool' = True, split_vertices: 'bool' = False, flip_normals: 'bool' = False, consistent_normals: 'bool' = True, auto_orient_normals: 'bool' = False, non_manifold_traversal: 'bool' = True, feature_angle=30.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Compute point and/or cell normals for a mesh.
|
| The filter can reorder polygons to insure consistent
| orientation across polygon neighbors. Sharp edges can be split
| and points duplicated with separate normals to give crisp
| (rendered) surface definition. It is also possible to globally
| flip the normal orientation.
|
| The algorithm works by determining normals for each polygon
| and then averaging them at shared points. When sharp edges are
| present, the edges are split and new points generated to
| prevent blurry edges (due to Phong shading).
|
| An array named ``"Normals"`` is stored with the mesh.
|
| .. warning::
|
| - Normals can only be computed for polygons and triangle strips.
| Point clouds are not supported.
| - Triangle strips are broken up into triangle polygons.
| You may want to restrip the triangles.
| - Previous arrays named ``"Normals"`` will be overwritten.
|
| Parameters
| ----------
| cell_normals : bool, default: True
| Calculation of cell normals.
|
| point_normals : bool, default: True
| Calculation of point normals.
|
| split_vertices : bool, default: False
| Splitting of sharp edges. Indices to the original points are
| tracked in the ``"pyvistaOriginalPointIds"`` array.
|
| flip_normals : bool, default: False
| Set global flipping of normal orientation. Flipping
| modifies both the normal direction and the order of a
| cell's points.
|
| consistent_normals : bool, default: True
| Enforcement of consistent polygon ordering.
|
| auto_orient_normals : bool, default: False
| Turn on/off the automatic determination of correct normal
| orientation. NOTE: This assumes a completely closed
| surface (i.e. no boundary edges) and no non-manifold
| edges. If these constraints do not hold, all bets are
| off. This option adds some computational complexity, and
| is useful if you do not want to have to inspect the
| rendered image to determine whether to turn on the
| ``flip_normals`` flag. However, this flag can work with
| the ``flip_normals`` flag, and if both are set, all the
| normals in the output will point "inward".
|
| non_manifold_traversal : bool, default: True
| Turn on/off traversal across non-manifold edges. Changing
| this may prevent problems where the consistency of
| polygonal ordering is corrupted due to topological
| loops.
|
| feature_angle : float, default: 30.0
| The angle that defines a sharp edge. If the difference in
| angle across neighboring polygons is greater than this
| value, the shared edge is considered "sharp".
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Raises
| ------
| TypeError
| If the mesh contains only ``LINE`` or ``VERTEX`` cell types.
| Normals cannot be computed for these cells.
|
| Returns
| -------
| pyvista.PolyData
| Updated mesh with cell and point normals.
|
| See Also
| --------
| pyvista.PolyData.point_normals
| Returns the array of point normals.
| pyvista.PolyData.cell_normals
| Returns the array of cell normals.
| pyvista.PolyDataFilters.flip_normal_vectors
| Flip cell and point normals.
| pyvista.PolyDataFilters.flip_faces
| Flip the orientation of the faces.
|
| Examples
| --------
| Compute the point normals of the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere = sphere.compute_normals(cell_normals=False)
| >>> normals = sphere['Normals']
| >>> normals.shape
| (842, 3)
|
| Alternatively, create a new mesh when computing the normals
| and compute both cell and point normals.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_with_norm = sphere.compute_normals()
| >>> sphere_with_norm.point_data['Normals'].shape
| (842, 3)
| >>> sphere_with_norm.cell_data['Normals'].shape
| (1680, 3)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| contour_banded(self: 'PolyData', n_contours, rng=None, scalars=None, component=0, clip_tolerance=1e-06, generate_contour_edges: 'bool' = True, scalar_mode='value', clipping: 'bool' = True, progress_bar: 'bool' = False)
| Generate filled contours.
|
| Generates filled contours for :vtk:`vtkPolyData`. Filled contours are
| bands of cells that all have the same cell scalar value, and can
| therefore be colored the same. The method is also referred to as
| filled contour generation.
|
| This filter implements :vtk:`vtkBandedPolyDataContourFilter`.
|
| Parameters
| ----------
| n_contours : int
| Number of contours.
|
| rng : Sequence, optional
| Range of the scalars. Optional and defaults to the minimum and
| maximum of the active scalars of ``scalars``.
|
| scalars : str, optional
| The name of the scalar array to use for contouring. If ``None``,
| the active scalar array will be used.
|
| component : int, default: 0
| The component to use of an input scalars array with more than one
| component.
|
| clip_tolerance : float, default: 1e-6
| Set/Get the clip tolerance. Warning: setting this too large will
| certainly cause numerical issues. Change from the default value at
| your own risk. The actual internal clip tolerance is computed by
| multiplying ``clip_tolerance`` by the scalar range.
|
| generate_contour_edges : bool, default: True
| Controls whether contour edges are generated. Contour edges are
| the edges between bands. If enabled, they are generated from
| polygons/triangle strips and returned as a second output.
|
| scalar_mode : str, default: 'value'
| Control whether the cell scalars are output as an integer index or
| a scalar value. If ``'index'``, the index refers to the bands
| produced by the clipping range. If ``'value'``, then a scalar value
| which is a value between clip values is used.
|
| clipping : bool, default: True
| Indicate whether to clip outside ``rng`` and only return cells with
| values within ``rng``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData
| Surface containing the contour surface.
|
| edges : pyvista.PolyData
| Optional edges when ``generate_contour_edges`` is ``True``.
|
| Examples
| --------
| Plot the random hills dataset and with 8 contour lines. Note how we use 7
| colors here (``n_contours - 1``).
|
| >>> import pyvista as pv
| >>> from pyvista import examples
|
| >>> mesh = examples.load_random_hills()
| >>> n_contours = 8
| >>> _, edges = mesh.contour_banded(n_contours)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... edges,
| ... line_width=5,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(mesh, n_colors=n_contours - 1, cmap='Set3')
| >>> pl.show()
|
| Extract the surface from the uniform grid dataset and plot its contours
| alongside the output from the banded contour filter.
|
| >>> surf = examples.load_uniform().extract_surface(algorithm=None)
| >>> n_contours = 5
| >>> rng = [200, 500]
| >>> output, edges = surf.contour_banded(n_contours, rng=rng)
|
| >>> dargs = dict(n_colors=n_contours - 1, clim=rng)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... edges,
| ... line_width=5,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(surf, opacity=0.3, **dargs)
| >>> _ = pl.add_mesh(output, **dargs)
| >>> pl.show()
|
| curvature(self, curv_type='mean', progress_bar: 'bool' = False)
| Return the pointwise curvature of a mesh.
|
| See :ref:`connectivity_example` for more examples using this
| filter.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| Curvature type. One of the following:
|
| * ``"mean"``
| * ``"gaussian"``
| * ``"maximum"``
| * ``"minimum"``
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Array of curvature values.
|
| Examples
| --------
| Calculate the mean curvature of the hills example mesh and plot it.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> curv = hills.curvature()
| >>> hills.plot(scalars=curv)
|
| Show the curvature array.
|
| >>> curv # doctest:+SKIP
| array([0.20587616, 0.06747695, ..., 0.11781171, 0.15988467])
|
| decimate(self, target_reduction, volume_preservation: 'bool' = False, attribute_error: 'bool | None' = None, scalars: 'bool | None' = None, vectors: 'bool | None' = None, normals: 'bool | None' = None, tcoords: 'bool | None' = None, tensors: 'bool | None' = None, scalars_weight=0.1, vectors_weight=0.1, normals_weight=0.1, tcoords_weight=0.1, tensors_weight=0.1, inplace: 'bool' = False, progress_bar: 'bool' = False, boundary_constraints: 'bool' = False, boundary_weight: 'float' = 1.0, enable_all_attribute_error: 'bool' = False)
| Reduce the number of triangles in a triangular mesh using :vtk:`vtkQuadricDecimation`.
|
| .. versionchanged:: 0.45
| ``scalars``, ``vectors``, ``normals``, ``tcoords`` and ``tensors`` are now disabled by
| default. They can be enabled all together using ``enable_all_attribute_error``.
|
|
| Parameters
| ----------
| target_reduction : float
| Fraction of the original mesh to remove.
| If ``target_reduction`` is set to 0.9, this filter will try
| to reduce the data set to 10% of its original size and will
| remove 90% of the input triangles.
|
| volume_preservation : bool, default: False
| Decide whether to activate volume preservation which greatly
| reduces errors in triangle normal direction. If ``False``,
| volume preservation is disabled and if ``attribute_error``
| is active, these errors can be large.
|
| attribute_error : bool, default: False
| Decide whether to include data attributes in the error metric. If
| ``False``, then only geometric error is used to control the
| decimation. If ``True``, the following flags are used to specify
| which attributes are to be included in the error calculation.
|
| .. deprecated:: 0.45.0
|
| scalars : bool, default: False
| This flags control specifically if the **scalar** attributes
| are to be included in the error calculation.
|
| vectors : bool, default: False
| See ``scalars`` parameter.
|
| normals : bool, default: False
| See ``scalars`` parameter.
| .. versionchanged:: 0.45.0
|
| tcoords : bool, default: False
| See ``scalars`` parameter.
|
| tensors : bool, default: False
| See ``scalars`` parameter.
|
| scalars_weight : float, default: 0.1
| The scaling weight contribution of the scalar attribute.
| These values are used to weight the contribution of the
| attributes towards the error metric.
|
| vectors_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| normals_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| tcoords_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| tensors_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| boundary_constraints: bool, default: False
| Use the legacy weighting by boundary_edge_length instead of by
| boundary_edge_length^2 for backwards compatibility.
| It requires vtk>=9.3.0.
|
| .. versionadded:: 0.45.0
|
| boundary_weight: float, default: 1.0
| A floating point factor to weigh the boundary quadric constraints
| by: higher factors further constrain the boundary.
| It requires vtk>=9.3.0.
|
| .. versionadded:: 0.45.0
|
| enable_all_attribute_error: bool, default: False
| This flag control the default value of all attribute metrics to
| eventually include them in the error calculation
|
| .. versionadded:: 0.45.0
|
| Returns
| -------
| pyvista.PolyData
| Decimated mesh.
|
| See Also
| --------
| decimate_pro
| Another option for triangular meshes.
| decimate_polyline
| For use with polylines.
|
| Notes
| -----
| If you encounter a segmentation fault or other error, consider using
| :func:`pyvista.PolyDataFilters.clean` to remove any invalid cells
| before using this filter.
|
| Examples
| --------
| Decimate a sphere. First plot the sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=60, theta_resolution=60)
| >>> sphere.plot(show_edges=True, line_width=2)
|
| Now decimate it by 75% and plot it.
|
| >>> decimated = sphere.decimate(0.75)
| >>> decimated.plot(show_edges=True, line_width=2)
|
| Decimate taking scalars attributes into account:
|
| >>> decimated = sphere.decimate(0.5, scalars=True)
|
| Decimate taking all attributes **except** normals into account:
|
| >>> decimated = sphere.decimate(
| ... 0.5, enable_all_attribute_error=True, normals=False
| ... )
|
| See :ref:`decimate_example` for more examples using this filter.
|
| decimate_polyline(self, reduction: 'float', *, maximum_error: 'float' = 10.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Reduce the number of lines in a polyline mesh.
|
| This filter uses :vtk:`vtkDecimatePolylineFilter`.
|
| .. versionadded:: 0.45.0
|
| Parameters
| ----------
| reduction : float
| Reduction factor. A value of 0.9 will leave 10% of the
| original number of vertices.
|
| maximum_error : float, default: 10.
| Fraction of the maximum length of the input data bounding box
| to limit reduction. This might prevent the full reduction from
| being achieved. Default of ``10.`` should not limit reduction.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated mesh.
|
| Warnings
| --------
| From :vtk:`vtkDecimatePolylineFilter` documentation: this algorithm is a very
| simple implementation that overlooks some potential complexities.
| For example, if a vertex is multiply connected, meaning that it is
| used by multiple distinct polylines, then the extra topological
| constraints are ignored. This can produce less than optimal results.
|
| See Also
| --------
| decimate
| For use with triangular meshes.
| decimate_pro
| Another option for triangular meshes.
|
| Examples
| --------
| Generate a circle, builtin function returns a Polygon cell.
|
| >>> import pyvista as pv
| >>> circle = pv.Circle(resolution=30)
|
| Convert to a Polyline. A polyline requires duplicating reference
| to initial point to close the circle.
|
| >>> circle_polyline = pv.PolyData(
| ... circle.points, lines=[31] + list(range(30)) + [0]
| ... )
| >>> circle_polyline.n_points
| 30
|
| Decimate ~50% of points.
|
| >>> decimate_some = circle_polyline.decimate_polyline(0.5)
| >>> decimate_some.n_points
| 14
|
| Decimate more points.
|
| >>> decimate_more = circle_polyline.decimate_polyline(0.75)
| >>> decimate_more.n_points
| 6
|
| Compare decimated polylines.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(circle_polyline, label='Circle', color='red', line_width=5)
| >>> _ = pl.add_mesh(
| ... decimate_some,
| ... label='Decimated some',
| ... color='blue',
| ... line_width=5,
| ... )
| >>> _ = pl.add_mesh(
| ... decimate_more,
| ... label='Decimated more',
| ... color='black',
| ... line_width=5,
| ... )
| >>> pl.view_xy()
| >>> _ = pl.add_legend(face='line', size=(0.25, 0.25))
| >>> pl.show()
|
| See :ref:`decimate_example` for more examples using this filter.
|
| decimate_pro(self, reduction, feature_angle=45.0, split_angle=75.0, splitting: 'bool' = True, pre_split_mesh: 'bool' = False, preserve_topology: 'bool' = False, boundary_vertex_deletion: 'bool' = True, max_degree=None, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Reduce the number of triangles in a triangular mesh.
|
| It forms a good approximation to the original geometry. Based
| on the algorithm originally described in "Decimation of
| Triangle Meshes", Proc Siggraph 92
| (https://doi.org/10.1145/133994.134010).
|
| Parameters
| ----------
| reduction : float
| Reduction factor. A value of 0.9 will leave 10% of the
| original number of vertices.
|
| feature_angle : float, default: 45.0
| Angle used to define what an edge is (i.e., if the surface
| normal between two adjacent triangles is >= ``feature_angle``,
| an edge exists).
|
| split_angle : float, default: 75.0
| Angle used to control the splitting of the mesh. A split
| line exists when the surface normals between two edge
| connected triangles are >= ``split_angle``.
|
| splitting : bool, default: True
| Controls the splitting of the mesh at corners, along
| edges, at non-manifold points, or anywhere else a split is
| required. Turning splitting off will better preserve the
| original topology of the mesh, but may not necessarily
| give the exact requested decimation.
|
| pre_split_mesh : bool, default: False
| Separates the mesh into semi-planar patches, which are
| disconnected from each other. This can give superior
| results in some cases. If ``pre_split_mesh`` is set to
| ``True``, the mesh is split with the specified
| ``split_angle``. Otherwise mesh splitting is deferred as
| long as possible.
|
| preserve_topology : bool, default: False
| Controls topology preservation. If on, mesh splitting and
| hole elimination will not occur. This may limit the
| maximum reduction that may be achieved.
|
| boundary_vertex_deletion : bool, default: True
| Allow deletion of vertices on the boundary of the mesh.
| Turning this off may limit the maximum reduction that may
| be achieved.
|
| max_degree : float, optional
| The maximum vertex degree. If the number of triangles
| connected to a vertex exceeds ``max_degree``, then the
| vertex will be split. The complexity of the triangulation
| algorithm is proportional to ``max_degree**2``. Setting ``max_degree``
| small can improve the performance of the algorithm.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated mesh.
|
| See Also
| --------
| decimate
| Another option for triangular meshes.
| decimate_polyline
| For use with polylines.
|
| Examples
| --------
| Decimate a sphere. First plot the sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=60, theta_resolution=60)
| >>> sphere.plot(show_edges=True, line_width=2)
|
| Now decimate it and plot it.
|
| >>> decimated = sphere.decimate_pro(0.75)
| >>> decimated.plot(show_edges=True, line_width=2)
|
| See :ref:`decimate_example` for more examples using this filter.
|
| delaunay_2d(self, tol=1e-05, alpha=0.0, offset=1.0, bound: 'bool' = False, inplace: 'bool' = False, edge_source=None, progress_bar: 'bool' = False)
| Apply a 2D Delaunay filter along the best fitting plane.
|
| This filter can be used to generate a 2d surface from a set of
| points on a plane. If you want to create a surface from a
| point cloud, see :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| tol : float, default: 1e-05
| Specify a tolerance to control discarding of closely
| spaced points. This tolerance is specified as a fraction
| of the diagonal length of the bounding box of the points.
|
| alpha : float, default: 0.0
| Specify alpha (or distance) value to control output of
| this filter. For a non-zero alpha value, only edges or
| triangles contained within a sphere centered at mesh
| vertices will be output. Otherwise, only triangles will be
| output.
|
| offset : float, default: 1.0
| Specify a multiplier to control the size of the initial,
| bounding Delaunay triangulation.
|
| bound : bool, default: False
| Boolean controls whether bounding triangulation points
| and associated triangles are included in the
| output. These are introduced as an initial triangulation
| to begin the triangulation process. This feature is nice
| for debugging output.
|
| inplace : bool, default: False
| If ``True``, overwrite this mesh with the triangulated
| mesh.
|
| edge_source : pyvista.PolyData, optional
| Specify the source object used to specify constrained
| edges and loops. If set, and lines/polygons are defined, a
| constrained triangulation is created. The lines/polygons
| are assumed to reference points in the input point set
| (i.e. point ids are identical in the input and
| source).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh from the 2D delaunay filter.
|
| Examples
| --------
| First, generate 30 points on circle and plot them.
|
| >>> import pyvista as pv
| >>> points = pv.Polygon(n_sides=30).points
| >>> circle = pv.PolyData(points)
| >>> circle.plot(show_edges=True, point_size=15)
|
| Use :func:`delaunay_2d` to fill the interior of the circle.
|
| >>> filled_circle = circle.delaunay_2d()
| >>> filled_circle.plot(show_edges=True, line_width=5)
|
| Use the ``edge_source`` parameter to create a constrained delaunay
| triangulation and plot it.
|
| >>> squar = pv.Polygon(n_sides=4, radius=8, fill=False)
| >>> squar = squar.rotate_z(45, inplace=False)
| >>> circ0 = pv.Polygon(center=(2, 3, 0), n_sides=30, radius=1)
| >>> circ1 = pv.Polygon(center=(-2, -3, 0), n_sides=30, radius=1)
| >>> comb = circ0.append_polydata(circ1, squar)
| >>> tess = comb.delaunay_2d(edge_source=comb)
| >>> tess.plot(cpos='xy', show_edges=True)
|
| See :ref:`create_tri_surface_example` for more examples using this filter.
|
| edge_mask(self, angle, progress_bar: 'bool' = False)
| Return a mask of the points of a surface mesh with a surface angle greater than angle.
|
| Parameters
| ----------
| angle : float
| Angle to consider an edge.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Mask of points with an angle greater than ``angle``.
|
| Examples
| --------
| Plot the mask of points that exceed 45 degrees.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube().triangulate().subdivide(4)
| >>> mask = mesh.edge_mask(45)
| >>> mesh.plot(scalars=mask)
|
| Show the array of masked points.
|
| >>> mask # doctest:+SKIP
| array([ True, True, True, ..., False, False, False])
|
| extrude(self, vector, capping=None, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Sweep polygonal data creating a "skirt" from free edges.
|
| This will create a line from vertices.
|
| This takes polygonal data as input and generates polygonal
| data on output. The input dataset is swept according to some
| extrusion function and creates new polygonal primitives. These
| primitives form a "skirt" or swept surface. For example,
| sweeping a line results in a quadrilateral, and sweeping a
| triangle creates a "wedge".
|
| The skirt is generated by locating certain topological
| features. Free edges (edges of polygons or triangle strips
| only used by one polygon or triangle strips) generate
| surfaces. This is true also of lines or polylines. Vertices
| generate lines.
|
| .. versionchanged:: 0.32.0
| The ``capping`` keyword was added with a default of ``False``.
| The previously used VTK default corresponds to ``capping=True``.
| In a future version the default will be changed to ``True`` to
| match the behavior of the underlying VTK filter.
|
| Parameters
| ----------
| vector : numpy.ndarray or sequence
| Direction and length to extrude the mesh in.
|
| capping : bool, optional
| Control if the sweep of a 2D object is capped. The default is
| ``False``, which differs from VTK's default.
|
| .. warning::
| The ``capping`` keyword was added in version 0.32.0 with a
| default value of ``False``. In a future version this default
| will be changed to ``True`` to match the behavior of the
| underlying VTK filter. It is recommended to explicitly pass
| a value for this keyword argument to prevent future changes
| in behavior and warnings.
|
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extruded mesh.
|
| Examples
| --------
| Extrude a half circle arc.
|
| >>> import pyvista as pv
| >>> arc = pv.CircularArc(pointa=[-1, 0, 0], pointb=[1, 0, 0], center=[0, 0, 0])
| >>> mesh = arc.extrude([0, 0, 1], capping=False)
| >>> mesh.plot(color='lightblue')
|
| Extrude and cap an 8 sided polygon.
|
| >>> poly = pv.Polygon(n_sides=8)
| >>> mesh = poly.extrude((0, 0, 1.5), capping=True)
| >>> mesh.plot(line_width=5, show_edges=True)
|
| extrude_rotate(self, resolution=30, inplace: 'bool' = False, translation=0.0, dradius=0.0, angle=360.0, capping=None, rotation_axis=(0, 0, 1), progress_bar: 'bool' = False)
| Sweep polygonal data creating "skirt" from free edges/lines, and lines from vertices.
|
| This takes polygonal data as input and generates polygonal
| data on output. The input dataset is swept around the axis
| to create new polygonal primitives. These primitives form a
| "skirt" or swept surface. For example, sweeping a line results
| in a cylindrical shell, and sweeping a circle creates a torus.
|
| There are a number of control parameters for this filter. You
| can control whether the sweep of a 2D object (i.e., polygon or
| triangle strip) is capped with the generating geometry via the
| ``capping`` parameter. Also, you can control the angle of
| rotation, and whether translation along the axis is
| performed along with the rotation. (Translation is useful for
| creating "springs".) You also can adjust the radius of the
| generating geometry with the ``dradius`` parameter.
|
| The skirt is generated by locating certain topological
| features. Free edges (edges of polygons or triangle strips
| only used by one polygon or triangle strips) generate
| surfaces. This is true also of lines or polylines. Vertices
| generate lines.
|
| This filter can be used to model axisymmetric objects like
| cylinders, bottles, and wine glasses; or translational
| rotational symmetric objects like springs or corkscrews.
|
| .. versionchanged:: 0.32.0
| The ``capping`` keyword was added with a default of ``False``.
| The previously used VTK default corresponds to ``capping=True``.
| In a future version the default will be changed to ``True`` to
| match the behavior of the underlying VTK filter.
|
| Parameters
| ----------
| resolution : int, optional
| Number of pieces to divide line into.
|
| inplace : bool, default: False
| Overwrites the original mesh inplace.
|
| translation : float, optional
| Total amount of translation along the axis.
|
| dradius : float, optional
| Change in radius during sweep process.
|
| angle : float, optional
| The angle of rotation in degrees.
|
| capping : bool, optional
| Control if the sweep of a 2D object is capped. The default is
| ``False``, which differs from VTK's default.
|
| .. warning::
| The ``capping`` keyword was added in version 0.32.0 with a
| default value of ``False``. In a future version this default
| will be changed to ``True`` to match the behavior of the
| underlying VTK filter. It is recommended to explicitly pass
| a value for this keyword argument to prevent future changes
| in behavior and warnings.
|
| rotation_axis : numpy.ndarray or sequence, optional
| The direction vector of the axis around which the rotation is done.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Rotationally extruded mesh.
|
| See Also
| --------
| :ref:`extrude_rotate_example`
|
| Examples
| --------
| Create a "spring" using the rotational extrusion filter.
|
| >>> import pyvista as pv
| >>> profile = pv.Polygon(
| ... center=[1.25, 0.0, 0.0],
| ... radius=0.2,
| ... normal=(0, 1, 0),
| ... n_sides=30,
| ... )
| >>> extruded = profile.extrude_rotate(
| ... resolution=360,
| ... translation=4.0,
| ... dradius=0.5,
| ... angle=1500.0,
| ... capping=True,
| ... )
| >>> extruded.plot(smooth_shading=True)
|
| Create a "wine glass" using the rotational extrusion filter.
|
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [-0.18, 0, 0],
| ... [-0.18, 0, 0.01],
| ... [-0.18, 0, 0.02],
| ... [-0.01, 0, 0.03],
| ... [-0.01, 0, 0.04],
| ... [-0.02, 0, 0.5],
| ... [-0.05, 0, 0.75],
| ... [-0.1, 0, 0.8],
| ... [-0.2, 0, 1.0],
| ... ]
| ... )
| >>> spline = pv.Spline(points, 30)
| >>> extruded = spline.extrude_rotate(resolution=20, capping=False)
| >>> extruded.plot(color='lightblue')
|
| extrude_trim(self, direction, trim_surface, extrusion='boundary_edges', capping='intersection', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extrude polygonal data trimmed by a surface.
|
| The input dataset is swept along a specified direction forming a
| "skirt" from the boundary edges 2D primitives (i.e., edges used
| by only one polygon); and/or from vertices and lines. The extent
| of the sweeping is defined where the sweep intersects a
| user-specified surface.
|
| Parameters
| ----------
| direction : numpy.ndarray or sequence
| Direction vector to extrude.
|
| trim_surface : pyvista.PolyData
| Surface which trims the surface.
|
| extrusion : str, default: "boundary_edges"
| Control the strategy of extrusion. One of the following:
|
| * ``"boundary_edges"``
| * ``"all_edges"``
|
| The default only generates faces on the boundary of the original
| input surface. When using ``"all_edges"``, faces are created along
| interior points as well.
|
| capping : str, default: "intersection"
| Control the strategy of capping. One of the following:
|
| * ``"intersection"``
| * ``"minimum_distance"``
| * ``"maximum_distance"``
| * ``"average_distance"``
|
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extruded mesh trimmed by a surface.
|
| See Also
| --------
| :ref:`extrude_trim_example`
|
| Examples
| --------
| Extrude a disc.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> plane = pv.Plane(i_size=2, j_size=2, direction=[0, 0.8, 1])
| >>> disc = pv.Disc(center=(0, 0, -1), c_res=50)
| >>> direction = [0, 0, 1]
| >>> extruded_disc = disc.extrude_trim(direction, plane)
| >>> extruded_disc.plot(smooth_shading=True, split_sharp_edges=True)
|
| fill_holes(self, hole_size, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Fill holes in a :class:`pyvista.PolyData` or :vtk:`vtkPolyData` object.
|
| Holes are identified by locating boundary edges, linking them
| together into loops, and then triangulating the resulting
| loops. Note that you can specify an approximate limit to the
| size of the hole that can be filled.
|
| .. warning::
| This method is known to segfault. Use at your own risk.
|
| Parameters
| ----------
| hole_size : float
| Specifies the maximum hole size to fill. This is
| represented as a radius to the bounding circumsphere
| containing the hole. Note that this is an approximate
| area; the actual area cannot be computed without first
| triangulating the hole.
|
| inplace : bool, default: False
| Return new mesh or overwrite input.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh with holes filled if ``inplace=False``.
|
| Examples
| --------
| Create a partial sphere with a hole and then fill it.
|
| >>> import pyvista as pv
| >>> sphere_with_hole = pv.Sphere(end_theta=330)
| >>> sphere = sphere_with_hole.fill_holes(1000) # doctest:+SKIP
| >>> edges = sphere.extract_feature_edges(
| ... feature_edges=False, manifold_edges=False
| ... ) # doctest:+SKIP
| >>> assert edges.n_cells == 0 # doctest:+SKIP
|
| See :ref:`fill_holes_example` for more examples using this filter.
|
| flip_faces(self: 'PolyData', *, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Flip the orientation of the faces.
|
| The flip is performed by reversing the order of indices in the cell
| connectivity list. In other libraries, this operation is sometimes
| referred to as "flip orientation", "reverse cells", "reverse face
| orientations", or similar.
|
| .. note::
|
| Polygon cells have an implicitly-defined orientation, and reversing
| the ordering affects how normals are computed by filters like
| :meth:`~pyvista.PolyDataFilters.compute_normals`.
|
| .. note::
| This filter does not modify any existing normals which may be present
| in the dataset. Use :meth:`~pyvista.PolyDataFilters.flip_normal_vectors`
| to flip the normal vectors.
|
| .. warning::
|
| This filter does not produce the correct output for
| :attr:`~pyvista.CellType.TRIANGLE_STRIP` cells,
| see https://gitlab.kitware.com/vtk/vtk/-/issues/18634.
| Use :meth:`~pyvista.PolyDataFilters.triangulate` to triangulate the mesh
| first.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh with flipped faces.
|
| See Also
| --------
| pyvista.PolyDataFilters.flip_normal_vectors
| Flip the direction of the point and cell normals.
| pyvista.PolyDataFilters.compute_normals
| Compute new normals. Includes the option to flip the normals.
| pyvista.PolyData.point_normals
| Returns the array of point normals.
| pyvista.PolyData.cell_normals
| Returns the array of cell normals.
|
| Examples
| --------
| Flip the faces of a sphere. Show the point ids of the first cell
| before and after the flip.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.regular_faces[0]
| array([ 2, 30, 0])
|
| >>> sphere_flipped = sphere.flip_faces()
| >>> sphere_flipped.regular_faces[0]
| array([ 0, 30, 2])
|
| Note that the sphere also has pre-computed normals which have not been
| affected by this filter.
|
| >>> sphere.point_data['Normals'][0]
| pyvista_ndarray([0., 0., 1.], dtype=float32)
|
| >>> sphere_flipped.point_data['Normals'][0]
| pyvista_ndarray([0., 0., 1.], dtype=float32)
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| flip_normal_vectors(self: 'PolyData', *, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Flip the direction of the mesh's point and cell normal vectors.
|
| This filter effectively multiplies the point and cell normals by ``-1``.
| It has no effect if no active normals are currently set.
|
| .. note::
|
| Polygon cells have an implicitly-defined orientation which may differ
| from the orientation of the normal vectors. To ensure that the normals
| are consistent with this implicit definition, consider also using
| :meth:`~pyvista.PolyDataFilters.flip_faces` or re-computing normals with
| :meth:`~pyvista.PolyDataFilters.compute_normals` and enabling the
| `flip_normals` option.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh with point and cell normal directions flipped.
|
| See Also
| --------
| pyvista.PolyDataFilters.flip_faces
| Flip the orientation of the faces.
| pyvista.PolyDataFilters.compute_normals
| Compute new normals. Includes the option to flip the normals.
| pyvista.PolyData.point_normals
| Returns the array of point normals.
| pyvista.PolyData.cell_normals
| Returns the array of cell normals.
|
| Examples
| --------
| Flip the normal vectors of a sphere. Show one of the normal vectors
| before and after the flip.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.point_data['Normals'][0]
| pyvista_ndarray([0., 0., 1.], dtype=float32)
|
| >>> sphere_flipped = sphere.flip_normal_vectors()
| >>> sphere_flipped.point_data['Normals'][0]
| pyvista_ndarray([-0., -0., -1.], dtype=float32)
|
| Note that the sphere's cell ordering has not been affected by this filter.
|
| >>> sphere.regular_faces[0]
| array([ 2, 30, 0])
|
| >>> sphere_flipped.regular_faces[0]
| array([ 2, 30, 0])
|
| flip_normals(self)
| Flip normals of a triangular mesh by reversing the point ordering.
|
| .. deprecated:: 0.45
|
| This filter is deprecated. Use ``flip_faces(inplace=True)`` instead.
|
| Examples
| --------
| Flip the normals of a sphere and plot the normals before and
| after the flip.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.plot_normals(mag=0.1)
| >>> sphere.flip_normals() # doctest:+SKIP
| >>> sphere.plot_normals(mag=0.1, opacity=0.5)
|
| geodesic(self, start_vertex, end_vertex, inplace: 'bool' = False, keep_order: 'bool' = True, use_scalar_weights: 'bool' = False, progress_bar: 'bool' = False)
| Calculate the geodesic path between two vertices using Dijkstra's algorithm.
|
| This will add an array titled ``'vtkOriginalPointIds'`` of the input
| mesh's point ids to the output mesh. The default behavior of the
| underlying :vtk:`vtkDijkstraGraphGeodesicPath` filter is that the
| geodesic path is reversed in the resulting mesh. This is overridden
| in PyVista by default.
|
| Parameters
| ----------
| start_vertex : int
| Vertex index indicating the start point of the geodesic segment.
|
| end_vertex : int
| Vertex index indicating the end point of the geodesic segment.
|
| inplace : bool, default: False
| Whether the input mesh should be replaced with the path. The
| geodesic path is always returned.
|
| keep_order : bool, default: True
| If ``True``, the points of the returned path are guaranteed
| to start with the start vertex (as opposed to the end vertex).
|
| .. versionadded:: 0.32.0
|
| use_scalar_weights : bool, default: False
| If ``True``, use scalar values in the edge weight.
| This only works for point data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| ``PolyData`` object consisting of the line segment between the
| two given vertices. If ``inplace`` is ``True`` this is the
| same object as the input mesh.
|
| Examples
| --------
| Plot the path between two points on the random hills mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> path = hills.geodesic(560, 5820)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills)
| >>> _ = pl.add_mesh(path, line_width=5, color='k')
| >>> pl.show()
|
| See :ref:`geodesic_example` for more examples using this filter.
|
| geodesic_distance(self, start_vertex, end_vertex, use_scalar_weights: 'bool' = False, progress_bar: 'bool' = False)
| Calculate the geodesic distance between two vertices using Dijkstra's algorithm.
|
| Parameters
| ----------
| start_vertex : int
| Vertex index indicating the start point of the geodesic segment.
|
| end_vertex : int
| Vertex index indicating the end point of the geodesic segment.
|
| use_scalar_weights : bool, default: False
| If ``True``, use scalar values in the edge weight.
| This only works for point data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| float
| Length of the geodesic segment.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> length = sphere.geodesic_distance(0, 100)
| >>> f'Length is {length:.3f}'
| 'Length is 0.812'
|
| See :ref:`geodesic_example` for more examples using this filter.
|
| intersection(self, mesh, split_first: 'bool' = True, split_second: 'bool' = True, progress_bar: 'bool' = False)
| Compute the intersection between two meshes.
|
| .. note::
| This method returns the surface intersection from two meshes
| (which often resolves as a line), whereas the
| :func:`PolyDataFilters.boolean_intersection` filter returns
| the "volume" intersection between two closed (manifold)
| meshes.
|
| Parameters
| ----------
| mesh : pyvista.PolyData
| The mesh to intersect with.
|
| split_first : bool, default: True
| If ``True``, return the first input mesh split by the
| intersection with the second input mesh.
|
| split_second : bool, default: True
| If ``True``, return the second input mesh split by the
| intersection with the first input mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The intersection line.
|
| pyvista.PolyData
| The first mesh split along the intersection. Returns the
| original first mesh if ``split_first=False``.
|
| pyvista.PolyData
| The second mesh split along the intersection. Returns the
| original second mesh if ``split_second=False``.
|
| Examples
| --------
| Intersect two spheres, returning the intersection and both spheres
| which have new points/cells along the intersection line.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> s1 = pv.Sphere(phi_resolution=15, theta_resolution=15)
| >>> s2 = s1.copy()
| >>> s2.points += np.array([0.25, 0, 0])
| >>> intersection, s1_split, s2_split = s1.intersection(s2)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(s1, style='wireframe')
| >>> _ = pl.add_mesh(s2, style='wireframe')
| >>> _ = pl.add_mesh(intersection, color='r', line_width=10)
| >>> pl.show()
|
| The mesh splitting takes additional time and can be turned
| off for either mesh individually.
|
| >>> intersection, _, s2_split = s1.intersection(
| ... s2, split_first=False, split_second=True
| ... )
|
| merge(self: 'PolyData', dataset, merge_points: 'bool' = True, tolerance=0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Merge this mesh with one or more datasets.
|
| .. note::
| The behavior of this filter varies from the
| :func:`PolyDataFilters.boolean_union` filter. This filter
| does not attempt to create a manifold mesh and will include
| internal surfaces when two meshes overlap.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the other mesh is also a
| :class:`pyvista.PolyData`, in-place merging via ``+=`` is
| similarly possible.
|
| .. versionchanged:: 0.39.0
| Before version ``0.39.0``, if all input datasets were of type
| :class:`pyvista.PolyData`, the VTK :vtk:`vtkAppendPolyData` and
| :vtk:`vtkCleanPolyData` filters were used to perform merging.
| Otherwise, :func:`DataSetFilters.merge`, which uses the VTK
| :vtk:`vtkAppendFilter` filter, was called.
| To enhance performance and coherence with merging operations
| available for other datasets in pyvista, the merging operation
| has been delegated in ``0.39.0`` to :func:`DataSetFilters.merge`
| only, irrespectively of input datasets types.
| This induced that points ordering can be altered compared to
| previous pyvista versions when merging only PolyData together.
| To obtain similar results as before ``0.39.0`` for multiple PolyData, combine
| :func:`PolyDataFilters.append_polydata` and :func:`PolyDataFilters.clean`.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| .. seealso::
| :func:`PolyDataFilters.append_polydata`
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| PyVista dataset to merge this mesh with.
|
| merge_points : bool, optional
| Merge equivalent points when ``True``.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when ``True`` if the input type is a
| :class:`pyvista.PolyData`. For other input meshes the
| result is a :class:`pyvista.UnstructuredGrid` which makes
| in-place operation impossible.
|
| main_has_priority : bool, optional
| When this parameter is ``True`` and ``merge_points=True``,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| :class:`pyvista.PolyData` if ``dataset`` is a
| :class:`pyvista.PolyData`, otherwise a
| :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> merged = sphere_a.merge(sphere_b)
| >>> merged.plot(style='wireframe', color='lightblue')
|
| multi_ray_trace(self: 'PolyData', origins, directions, first_point: 'bool' = False, retry: 'bool' = False)
| Perform multiple ray trace calculations.
|
| This requires a mesh with only triangular faces, an array of
| origin points and an equal sized array of direction vectors to
| trace along.
|
| The embree library used for vectorization of the ray traces is
| known to occasionally return no intersections where the VTK
| implementation would return an intersection. If the result
| appears to be missing some intersection points, set
| ``retry=True`` to run a second pass over rays that returned no
| intersections, using :func:`PolyDataFilters.ray_trace`.
|
| Parameters
| ----------
| origins : array_like[float]
| Starting point for each trace.
|
| directions : array_like[float]
| Direction vector for each trace.
|
| first_point : bool, default: False
| Returns intersection of first point only.
|
| retry : bool, default: False
| Will retry rays that return no intersections using
| :func:`PolyDataFilters.ray_trace`.
|
| Returns
| -------
| intersection_points : numpy.ndarray
| Location of the intersection points. Empty array if no
| intersections.
|
| intersection_rays : numpy.ndarray
| Indices of the ray for each intersection point. Empty array if no
| intersections.
|
| intersection_cells : numpy.ndarray
| Indices of the intersection cells. Empty array if no
| intersections.
|
| Examples
| --------
| Compute the intersection between rays from the origin in
| directions ``[1, 0, 0]``, ``[0, 1, 0]`` and ``[0, 0, 1]``, and
| a sphere with radius 0.5 centered at the origin
|
| >>> import pyvista as pv # doctest:+SKIP
| >>> sphere = pv.Sphere() # doctest:+SKIP
| >>> points, rays, cells = sphere.multi_ray_trace(
| ... [[0, 0, 0]] * 3,
| ... [[1, 0, 0], [0, 1, 0], [0, 0, 1]],
| ... first_point=True,
| ... ) # doctest:+SKIP
| >>> string = ', '.join(
| ... [
| ... f'({point[0]:.3f}, {point[1]:.3f}, {point[2]:.3f})'
| ... for point in points
| ... ]
| ... ) # doctest:+SKIP
| >>> f'Rays intersected at {string}' # doctest:+SKIP
| 'Rays intersected at (0.499, 0.000, 0.000), (0.000, 0.497, 0.000), (0.000, 0.000, 0.500)'
|
| plot_boundaries(self: 'PolyData', edge_color='red', line_width=None, progress_bar: 'bool' = False, **kwargs)
| Plot boundaries of a mesh.
|
| Parameters
| ----------
| edge_color : ColorLike, default: "red"
| The color of the edges when they are added to the plotter.
|
| line_width : int, optional
| Width of the boundary lines.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| All additional keyword arguments will be passed to
| :func:`pyvista.Plotter.add_mesh`.
|
| Returns
| -------
| pyvista.CameraPosition
| List of camera position, focal point, and view up.
| Returned when ``return_cpos`` is ``True``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot_boundaries(line_width=10)
|
| plot_curvature(self, curv_type='mean', **kwargs)
| Plot the curvature.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| One of the following strings indicating curvature type:
|
| * ``'mean'``
| * ``'gaussian'``
| * ``'maximum'``
| * ``'minimum'``
|
| **kwargs : dict, optional
| See :func:`pyvista.plot`.
|
| Returns
| -------
| pyvista.CameraPosition
| List of camera position, focal point, and view up.
| Returned when ``return_cpos`` is ``True``.
|
| Examples
| --------
| Plot the Gaussian curvature of an example mesh. Override the
| default scalar bar range as the mesh edges report high
| curvature.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot_curvature(
| ... curv_type='gaussian', smooth_shading=True, clim=[0, 1]
| ... )
|
| plot_normals(self: 'PolyData', show_mesh: 'bool' = True, mag=1.0, flip: 'bool' = False, use_every=1, faces: 'bool' = False, color=None, **kwargs)
| Plot the point normals of a mesh.
|
| Parameters
| ----------
| show_mesh : bool, default: True
| Plot the mesh itself.
|
| mag : float, default: 1.0
| Size magnitude of the normal arrows.
|
| flip : bool, default: False
| Flip the normal direction when ``True``.
|
| use_every : int, default: 1
| Display every nth normal. By default every normal is
| displayed. Display every 10th normal by setting this
| parameter to 10.
|
| faces : bool, default: False
| Plot face normals instead of the default point normals.
|
| color : ColorLike, optional
| Color of the arrows. Defaults to
| :attr:`pyvista.plotting.themes.Theme.edge_color`.
|
| **kwargs : dict, optional
| All additional keyword arguments will be passed to
| :func:`pyvista.Plotter.add_mesh`.
|
| Returns
| -------
| pyvista.CameraPosition
| List of camera position, focal point, and view up.
| Returned when ``return_cpos`` is ``True``.
|
| Examples
| --------
| Plot the point normals of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=10, theta_resolution=10)
| >>> sphere.plot_normals(mag=0.1, show_edges=True)
|
| Plot the face normals of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=10, theta_resolution=10)
| >>> sphere.plot_normals(mag=0.1, faces=True, show_edges=True)
|
| project_points_to_plane(self: 'PolyData', origin: 'VectorLike[float] | None' = None, normal: 'VectorLike[float] | _NormalsLiteral | None' = None, inplace: 'bool' = False, plane: 'PolyData | None' = None)
| Project points of this mesh to a plane.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| Parameters
| ----------
| origin : VectorLike[float], optional
| Plane origin. Defaults to the approximate center of the
| input mesh minus half the length of the input mesh in the
| direction of the normal.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector for the plane's normal. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'z'`` direction is used by default.
|
| inplace : bool, default: False
| Whether to overwrite the original mesh with the projected
| points.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to project to. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| The points of this mesh projected onto a plane.
|
| See Also
| --------
| :ref:`project_plane_example`
| :ref:`project_points_tessellate_example`
|
| Examples
| --------
| Flatten a sphere to the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> projected = sphere.project_points_to_plane()
|
| Plot the projected sphere along with the original.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(projected, show_edges=True, line_width=3)
| >>> _ = pl.add_mesh(sphere)
| >>> _ = pl.show_grid()
| >>> cpos = pv.CameraPosition(
| ... position=(2.5, 2.5, 1.1),
| ... focal_point=(0.0, 0.0, -0.3),
| ... viewup=(-0.25, -0.25, 1.0),
| ... )
| >>> pl.camera_position = cpos
| >>> pl.show()
|
| protein_ribbon(self, progress_bar: 'bool' = False)
| Generate protein ribbon.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Generated protein ribbon.
|
| Examples
| --------
| Generate protein ribbon.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> tgqp = examples.download_3gqp()
| >>> ribbon = tgqp.protein_ribbon()
| >>> ribbon.plot()
|
| ray_trace(self: 'PolyData', origin, end_point, first_point: 'bool' = False, plot: 'bool' = False, off_screen=None)
| Perform a single ray trace calculation.
|
| This requires a mesh and a line segment defined by an origin
| and end_point.
|
| .. warning::
|
| This filter uses the mesh's :attr:`~pyvista.PolyData.obbTree` property internally to
| compute the intersection. Since the obb tree is cached, the intersection may not be
| valid if the mesh's geometry is modified in between filter calls.
|
| Parameters
| ----------
| origin : sequence[float]
| Start of the line segment.
|
| end_point : sequence[float]
| End of the line segment.
|
| first_point : bool, default: False
| Returns intersection of first point only.
|
| plot : bool, default: False
| Whether to plot the ray trace results.
|
| off_screen : bool, optional
| Plots off screen when ``plot=True``. Used for unit testing.
|
| Returns
| -------
| intersection_points : numpy.ndarray
| Location of the intersection points. Empty array if no
| intersections.
|
| intersection_cells : numpy.ndarray
| Indices of the intersection cells. Empty array if no
| intersections.
|
| See Also
| --------
| :ref:`ray_trace_moeller_example`
| Example of ray-tracing using the Moeller-Trumbore intersection algorithm.
|
| Examples
| --------
| Compute the intersection between a ray from the origin to
| ``[1, 0, 0]`` and a sphere with radius 0.5 centered at the
| origin.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> point, cell = sphere.ray_trace([0, 0, 0], [1, 0, 0], first_point=True)
| >>> f'Intersected at {point[0]:.3f} {point[1]:.3f} {point[2]:.3f}'
| 'Intersected at 0.499 0.000 0.000'
|
| Show a plot of the ray trace.
|
| >>> point, cell = sphere.ray_trace([0, 0, 0], [1, 0, 0], plot=True)
|
| See :ref:`ray_trace_example` for more examples using this filter.
|
| reconstruct_surface(self, nbr_sz=None, sample_spacing=None, progress_bar: 'bool' = False)
| Reconstruct a surface from the points in this dataset.
|
| This filter takes a list of points assumed to lie on the
| surface of a solid 3D object. A signed measure of the distance
| to the surface is computed and sampled on a regular grid. The
| grid can then be contoured at zero to extract the surface. The
| default values for neighborhood size and sample spacing should
| give reasonable results for most uses but can be set if
| desired.
|
| This is helpful when generating surfaces from point clouds and
| is more reliable than :func:`DataSetFilters.delaunay_3d`.
|
| Parameters
| ----------
| nbr_sz : int, optional
| Specify the number of neighbors each point has, used for
| estimating the local surface orientation.
|
| The default value of 20 should be fine for most
| applications, higher values can be specified if the spread
| of points is uneven. Values as low as 10 may yield
| adequate results for some surfaces. Higher values cause
| the algorithm to take longer and will cause
| errors on sharp boundaries.
|
| sample_spacing : float, optional
| The spacing of the 3D sampling grid. If not set, a
| reasonable guess will be made.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Reconstructed surface.
|
| Examples
| --------
| Create a point cloud out of a sphere and reconstruct a surface
| from it.
|
| >>> import pyvista as pv
| >>> points = pv.wrap(pv.Sphere().points)
| >>> surf = points.reconstruct_surface()
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(points)
| >>> _ = pl.add_title('Point Cloud of 3D Surface')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(surf, color=True, show_edges=True)
| >>> _ = pl.add_title('Reconstructed Surface')
| >>> pl.show()
|
| See :ref:`surface_reconstruction_example` for more examples
| using this filter.
|
| remove_points(self, remove, mode='any', keep_scalars: 'bool' = True, inplace: 'bool' = False)
| Rebuild a mesh by removing points.
|
| Only valid for all-triangle meshes.
|
| Parameters
| ----------
| remove : sequence[bool | int]
| If remove is a bool array, points that are ``True`` will
| be removed. Otherwise, it is treated as a list of
| indices.
|
| mode : str, default: "any"
| When ``'all'``, only faces containing all points flagged
| for removal will be removed.
|
| keep_scalars : bool, default: True
| When ``True``, point and cell scalars will be passed on to
| the new mesh.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PolyData
| Mesh without the points flagged for removal.
|
| numpy.ndarray
| Indices of new points relative to the original mesh.
|
| Examples
| --------
| Remove the first 100 points from a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> reduced_sphere, ridx = sphere.remove_points(range(100, 250))
| >>> reduced_sphere.plot(show_edges=True, line_width=3)
|
| remove_unused_points(self: '_PolyDataType', *, inplace: 'bool' = False) -> '_PolyDataType'
| Remove points which are not used by any cells.
|
| This filter is similar to :meth:`clean` but does `not` merge points or convert cells.
| The point order is also unchanged by this filter.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy is returned.
|
| See Also
| --------
| pyvista.UnstructuredGridFilters.remove_unused_points
|
| Returns
| -------
| PolyData
| Mesh with unused points removed.
|
| Examples
| --------
| Create :class:`~pyvista.PolyData` with three points. The first two points are coincident
| and associated with :attr:`~pyvista.CellType.VERTEX` cells, and the third point is
| "unused" and not associated with any cells.
|
| >>> import pyvista as pv
| >>> points = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]
| >>> faces = [1, 0, 1, 1]
| >>> poly = pv.PolyData(points, faces)
| >>> poly
| PolyData (...)
| N Cells: 2
| N Points: 3
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 1.000e+00
| N Arrays: 0
|
| Since the third point is unused, we can remove it. Note that coincident points are `not`
| merged by this filter, so the two vertex points are kept as-is.
|
| >>> poly = poly.remove_unused_points()
| >>> poly
| PolyData (...)
| N Cells: 2
| N Points: 2
| N Strips: 0
| X Bounds: 0.000e+00, 0.000e+00
| Y Bounds: 0.000e+00, 0.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| N Arrays: 0
|
| ribbon(self, width=None, scalars=None, angle=0.0, factor=2.0, normal=None, tcoords: 'bool | str' = False, preference='points', progress_bar: 'bool' = False)
| Create a ribbon of the lines in this dataset.
|
| .. note::
| If there are no lines in the input dataset, then the output
| will be an empty :class:`pyvista.PolyData` mesh.
|
| Parameters
| ----------
| width : float, optional
| Set the "half" width of the ribbon. If the width is
| allowed to vary, this is the minimum width. The default is
| 10% the length.
|
| scalars : str, optional
| String name of the scalars array to use to vary the ribbon
| width. This is only used if a scalars array is specified.
|
| angle : float, optional
| Angle in degrees of the offset angle of the ribbon from
| the line normal. The default is 0.0.
|
| factor : float, optional
| Set the maximum ribbon width in terms of a multiple of the
| minimum width. The default is 2.0.
|
| normal : sequence[float], optional
| Normal to use as default.
|
| tcoords : bool, str, optional
| If ``True``, generate texture coordinates along the
| ribbon. This can also be specified to generate the texture
| coordinates with either ``'length'`` or ``'normalized'``.
|
| preference : str, optional
| The field preference when searching for the scalars array by
| name.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Ribbon mesh. Empty if there are no lines in the input dataset.
|
| Examples
| --------
| Convert a line to a ribbon and plot it.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> n = 1000
| >>> theta = np.linspace(-10 * np.pi, 10 * np.pi, n)
| >>> z = np.linspace(-2, 2, n)
| >>> r = z**2 + 1
| >>> x = r * np.sin(theta)
| >>> y = r * np.cos(theta)
| >>> points = np.column_stack((x, y, z))
| >>> pdata = pv.PolyData(points)
| >>> pdata.lines = np.hstack((n, range(n)))
| >>> pdata['distance'] = range(n)
| >>> ribbon = pdata.ribbon(width=0.2)
| >>> ribbon.plot(show_scalar_bar=False)
|
| ruled_surface(self, *, resolution: 'VectorLike[int] | None' = None, progress_bar: 'bool' = False)
| Create a ruled surface from a polyline.
|
| .. versionadded:: 0.45.0
|
| This filter is a filter that generates a surface from
| a set of lines. The lines are assumed to be "parallel"
| in the sense that they do not intersect and remain
| somewhat close to one another. A surface is generated
| by connecting the points defining each pair of lines
| with straight lines. This creates a strip for each pair
| of lines (i.e., a triangulation is created from two
| generating lines). The filter can handle an arbitrary
| number of lines, with lines i and i+1 assumed
| connected. Note that there are several different
| approaches for creating the ruled surface, the method
| for creating the surface can either use the input points
| or resample from the polylines (using a user-specified
| resolution).
|
| This filter implements :vtk:`vtkRuledSurfaceFilter`.
|
| Parameters
| ----------
| resolution : int, default: (1, 1)
| Set the number of points in the output polyline.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Ruled surface.
|
| Examples
| --------
| Create a ruled surface from a polyline.
|
| >>> import pyvista as pv
| >>> pl = pv.Plotter()
| >>> poly = pv.PolyData(
| ... [[0, 0, 1], [1, 0, 0], [0, 1, 0], [1, 1, 1]],
| ... lines=[[2, 0, 1], [2, 2, 3]],
| ... force_float=False,
| ... )
| >>> surface = poly.ruled_surface(resolution=(21, 21))
| >>> _ = pl.add_mesh(surface, show_edges=True)
| >>> pl.show()
|
| smooth(self, n_iter=20, relaxation_factor=0.01, convergence=0.0, edge_angle=15, feature_angle=45, boundary_smoothing: 'bool' = True, feature_smoothing: 'bool' = False, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Adjust point coordinates using Laplacian smoothing.
|
| The effect is to "relax" the mesh, making the cells better shaped and
| the vertices more evenly distributed.
|
| Parameters
| ----------
| n_iter : int, default: 20
| Number of iterations for Laplacian smoothing.
|
| relaxation_factor : float, default: 0.01
| Relaxation factor controls the amount of displacement in a single
| iteration. Generally a lower relaxation factor and higher number of
| iterations is numerically more stable.
|
| convergence : float, default: 0.0
| Convergence criterion for the iteration process. Smaller numbers
| result in more smoothing iterations. Range from (0 to 1).
|
| edge_angle : float, default: 15
| Edge angle to control smoothing along edges (either interior or boundary).
|
| feature_angle : float, default: 45
| Feature angle for sharp edge identification.
|
| boundary_smoothing : bool, default: True
| Flag to control smoothing of boundary edges. When ``True``,
| boundary edges remain fixed.
|
| feature_smoothing : bool, default: False
| Flag to control smoothing of feature edges. When ``True``,
| boundary edges remain fixed as defined by ``feature_angle`` and
| ``edge_angle``.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Smoothed mesh.
|
| Examples
| --------
| Smooth the edges of an all triangular cube
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(5)
| >>> smooth_cube = cube.smooth(n_iter=1000, feature_smoothing=False)
| >>> n_edge_cells = cube.extract_feature_edges().n_cells
| >>> n_smooth_cells = smooth_cube.extract_feature_edges().n_cells
| >>> f'Sharp Edges on Cube: {n_edge_cells}'
| 'Sharp Edges on Cube: 384'
| >>> f'Sharp Edges on Smooth Cube: {n_smooth_cells}'
| 'Sharp Edges on Smooth Cube: 12'
| >>> smooth_cube.plot()
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| smooth_taubin(self, n_iter=20, pass_band=0.1, edge_angle=15.0, feature_angle=45.0, boundary_smoothing: 'bool' = True, feature_smoothing: 'bool' = False, non_manifold_smoothing: 'bool' = False, normalize_coordinates: 'bool' = False, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Smooth a PolyData DataSet with Taubin smoothing.
|
| This filter allows you to smooth the mesh as in the Laplacian smoothing
| implementation in :func:`smooth() <PolyDataFilters.smooth>`. However,
| unlike Laplacian smoothing the surface does not "shrink" since this
| filter relies on an alternative approach to smoothing. This filter is
| more akin to a low pass filter where undesirable high frequency features
| are removed.
|
| This PyVista filter uses the VTK :vtk:`vtkWindowedSincPolyDataFilter`
| filter.
|
| Parameters
| ----------
| n_iter : int, default: 20
| This is the degree of the polynomial used to approximate the
| windowed sync function. This is generally much less than the number
| needed by :func:`smooth() <PolyDataFilters.smooth>`.
|
| pass_band : float, default: 0.1
| The passband value for the windowed sinc filter. This should be
| between 0 and 2, where lower values cause more smoothing.
|
| edge_angle : float, default: 15.0
| Edge angle to control smoothing along edges (either interior or
| boundary).
|
| feature_angle : float, default: 45.0
| Feature angle for sharp edge identification.
|
| boundary_smoothing : bool, default: True
| Flag to control smoothing of boundary edges. When ``True``,
| boundary edges remain fixed.
|
| feature_smoothing : bool, default: False
| Flag to control smoothing of feature edges. When ``True``,
| boundary edges remain fixed as defined by ``feature_angle`` and
| ``edge_angle``.
|
| non_manifold_smoothing : bool, default: False
| Smooth non-manifold points.
|
| normalize_coordinates : bool, default: False
| Flag to control coordinate normalization. To improve the
| numerical stability of the solution and minimize the scaling of the
| translation effects, the algorithm can translate and scale the
| position coordinates to within the unit cube ``[-1, 1]``, perform the
| smoothing, and translate and scale the position coordinates back to
| the original coordinate frame.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Smoothed mesh.
|
| Notes
| -----
| For maximum performance, do not enable ``feature_smoothing`` or
| ``boundary_smoothing``. ``feature_smoothing`` is especially expensive.
|
| References
| ----------
| See `Optimal Surface Smoothing as Filter Design
| <https://dl.acm.org/doi/pdf/10.1145/218380.218473>`_ for details
| regarding the implementation of Taubin smoothing.
|
| Examples
| --------
| Smooth the example bone mesh. Here, it's necessary to subdivide the
| mesh to increase the number of faces as the original mesh is so coarse.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_foot_bones().subdivide(2)
| >>> smoothed_mesh = mesh.smooth_taubin()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_text('Original Mesh')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(smoothed_mesh)
| >>> _ = pl.add_text('Smoothed Mesh')
| >>> pl.show()
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| strip(self, join: 'bool' = False, max_length=1000, pass_cell_data: 'bool' = False, pass_cell_ids: 'bool' = False, pass_point_ids: 'bool' = False, progress_bar: 'bool' = False)
| Strip poly data cells.
|
| Generates triangle strips and/or poly-lines from input
| polygons, triangle strips, and lines.
|
| Polygons are assembled into triangle strips only if they are
| triangles; other types of polygons are passed through to the
| output and not stripped. (Use ``triangulate`` filter to
| triangulate non-triangular polygons prior to running this
| filter if you need to strip all the data.) The filter will
| pass through (to the output) vertices if they are present in
| the input polydata.
|
| Also note that if triangle strips or polylines are defined in
| the input they are passed through and not joined nor
| extended. (If you wish to strip these use ``triangulate``
| filter to fragment the input into triangles and lines prior to
| running this filter.)
|
| This filter implements :vtk:`vtkStripper`.
|
| Parameters
| ----------
| join : bool, default: False
| If ``True``, the output polygonal segments will be joined
| if they are contiguous. This is useful after slicing a
| surface.
|
| max_length : int, default: 1000
| Specify the maximum number of triangles in a triangle
| strip, and/or the maximum number of lines in a poly-line.
|
| pass_cell_data : bool, default: False
| Enable/Disable passing of the CellData in the input to the
| output as FieldData. Note the field data is transformed.
|
| pass_cell_ids : bool, default: False
| If ``True``, the output polygonal dataset will have a
| celldata array that holds the cell index of the original
| 3D cell that produced each output cell. This is useful for
| picking. The default is ``False`` to conserve memory.
|
| pass_point_ids : bool, default: False
| If ``True``, the output polygonal dataset will have a
| pointdata array that holds the point index of the original
| vertex that produced each output vertex. This is useful
| for picking. The default is ``False`` to conserve memory.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Stripped mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> slc = mesh.slice(normal='z', origin=(0, 0, -10))
| >>> stripped = slc.strip()
| >>> stripped.n_cells
| 1
| >>> stripped.plot(show_edges=True, line_width=3)
|
| subdivide(self, nsub, subfilter='linear', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Increase the number of triangles in a single, connected triangular mesh.
|
| Uses one of the following vtk subdivision filters to subdivide a mesh:
|
| * :vtk:`vtkButterflySubdivisionFilter`
| * :vtk:`vtkLoopSubdivisionFilter`
| * :vtk:`vtkLinearSubdivisionFilter`
|
| Linear subdivision results in the fastest mesh subdivision,
| but it does not smooth mesh edges, but rather splits each
| triangle into 4 smaller triangles.
|
| Butterfly and loop subdivision perform smoothing when
| dividing, and may introduce artifacts into the mesh when
| dividing.
|
| .. note::
| Subdivision filter sometimes fails for multiple part
| meshes. The input should be one connected mesh.
|
| Parameters
| ----------
| nsub : int
| Number of subdivisions. Each subdivision creates 4 new
| triangles, so the number of resulting triangles is
| ``nface*4**nsub`` where ``nface`` is the current number of
| faces.
|
| subfilter : str, default: "linear"
| Can be one of the following:
|
| * ``'butterfly'``
| * ``'loop'``
| * ``'linear'``
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Subdivided mesh.
|
| Examples
| --------
| First, create an example coarse sphere mesh and plot it.
|
| >>> from pyvista import examples
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(phi_resolution=10, theta_resolution=10)
| >>> mesh.plot(show_edges=True, line_width=3)
|
| Subdivide the sphere mesh using linear subdivision.
|
| >>> submesh = mesh.subdivide(1, 'linear')
| >>> submesh.plot(show_edges=True, line_width=3)
|
| Subdivide the sphere mesh using loop subdivision.
|
| >>> submesh = mesh.subdivide(1, 'loop')
| >>> submesh.plot(show_edges=True, line_width=3)
|
| Subdivide the sphere mesh using butterfly subdivision.
|
| >>> submesh = mesh.subdivide(1, 'butterfly')
| >>> submesh.plot(show_edges=True, line_width=3)
|
| subdivide_adaptive(self, max_edge_len=None, max_tri_area=None, max_n_tris=None, max_n_passes=None, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Increase the number of triangles in a triangular mesh based on edge and/or area metrics.
|
| This filter uses a simple case-based, multi-pass approach to
| repeatedly subdivide the input triangle mesh to meet the area
| and/or edge length criteria. New points may be inserted only
| on edges; depending on the number of edges to be subdivided a
| different number of triangles are inserted ranging from two
| (i.e., two triangles replace the original one) to four.
|
| Point and cell data is treated as follows: The cell data from
| a parent triangle is assigned to its subdivided
| children. Point data is interpolated along edges as the edges
| are subdivided.
|
| This filter retains mesh watertightness if the mesh was
| originally watertight; and the area and max triangles criteria
| are not used.
|
| Parameters
| ----------
| max_edge_len : float, optional
| The maximum edge length that a triangle may have. Edges
| longer than this value are split in half and the
| associated triangles are modified accordingly.
|
| max_tri_area : float, optional
| The maximum area that a triangle may have. Triangles
| larger than this value are subdivided to meet this
| threshold. Note that if this criterion is used it may
| produce non-watertight meshes as a result.
|
| max_n_tris : int, optional
| The maximum number of triangles that can be created. If
| the limit is hit, it may result in premature termination
| of the algorithm and the results may be less than
| satisfactory (for example non-watertight meshes may be
| created). By default, the limit is set to a very large
| number (i.e., no effective limit).
|
| max_n_passes : int, optional
| The maximum number of passes (i.e., levels of
| subdivision). If the limit is hit, then the subdivision
| process stops and additional passes (needed to meet other
| criteria) are aborted. The default limit is set to a very
| large number (i.e., no effective limit).
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Subdivided mesh.
|
| Examples
| --------
| First, load the example airplane mesh and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.PolyData(examples.planefile)
| >>> mesh.plot(show_edges=True, line_width=3)
|
| Subdivide the mesh
|
| >>> submesh = mesh.subdivide_adaptive(max_n_passes=2)
| >>> submesh.plot(show_edges=True)
|
| triangulate(self, *, pass_verts: 'bool' = False, pass_lines: 'bool' = False, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| pass_verts : bool, default: False
| Whether vertices cells are passed to the output PolyData.
|
| .. versionadded:: 0.45.0
|
| pass_lines : bool, default: False
| Whether lines cells are passed to the output PolyData.
|
| .. versionadded:: 0.45.0
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| triangulate_contours(self: '_PolyDataType', display_errors: 'bool' = False, progress_bar: 'bool' = False) -> '_PolyDataType'
| Triangulate and fill all 2D contours to create polygons.
|
| .. versionadded:: 0.44.0
|
| This filter will generate triangles to fill all of the 2D contours
| in its input. The input to the filter is a set of lines (not polylines)
| which when joined form loops. The contours may be concave, and may even
| contain holes i.e. a contour may contain an internal contour that is
| wound in the opposite direction (as compared to the outer polygon
| normal) to indicate that it is a hole.
|
| .. note::
|
| This filter will assume that the input polygons lie in the same
| plane and will not perform any projection or transformation of the
| input data. You may need to project your data to a plane before
| using this filter.
|
| .. warning::
|
| The triangulation of is done in O(n) time for simple convex inputs,
| but for non-convex inputs the worst-case time is O(n^2*m^2) where n
| is the number of points and m is the number of holes. The best
| triangulation algorithms, in contrast, are O(n log n). The
| resulting triangles may be quite narrow, the algorithm does not
| attempt to produce high-quality triangles.
|
| Parameters
| ----------
| display_errors : bool, default: False
| Generate errors when the triangulation fails. Note that
| triangulation failures are often minor, because they involve tiny
| triangles that are too small to see.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Raises
| ------
| RuntimeError
| If the mesh does not contain lines.
|
| Returns
| -------
| pyvista.PolyData
| Triangulated mesh with the filled contours.
|
| Examples
| --------
| Create banded contour and fill.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.download_st_helens()
| >>> contours = image.contour([1302.3334, 1922.6666])
| >>> filled = contours.triangulate_contours()
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(image, show_scalar_bar=False)
| >>> _ = pl.add_mesh(contours, color='black')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(contours, color='black')
| >>> _ = pl.add_mesh(filled, color='red')
| >>> pl.link_views()
| >>> pl.view_xy()
| >>> pl.show()
|
| tube(self, radius=None, scalars=None, capping: 'bool' = True, n_sides=20, radius_factor=10.0, absolute: 'bool' = False, preference='point', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Generate a tube around each input line.
|
| The radius of the tube can be set to linearly vary with a
| scalar value.
|
| Parameters
| ----------
| radius : float, optional
| Minimum tube radius (minimum because the tube radius may
| vary).
|
| scalars : str, optional
| Scalars array by which the radius varies.
|
| capping : bool, default: True
| Turn on/off whether to cap the ends with polygons.
|
| n_sides : int, default: 20
| Set the number of sides for the tube. Minimum of 3.
|
| radius_factor : float, default: 10.0
| Maximum tube radius in terms of a multiple of the minimum
| radius.
|
| absolute : bool, default: False
| Vary the radius with values from scalars in absolute units.
|
| preference : str, default: 'point'
| The field preference when searching for the scalars array by
| name.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Tube-filtered mesh.
|
| Examples
| --------
| Convert a single line to a tube.
|
| >>> import pyvista as pv
| >>> line = pv.Line()
| >>> tube = line.tube(radius=0.02)
| >>> f'Line Cells: {line.n_cells}'
| 'Line Cells: 1'
| >>> f'Tube Cells: {tube.n_cells}'
| 'Tube Cells: 22'
| >>> tube.plot(color='lightblue')
|
| See :ref:`create_spline_example` for more examples using this filter.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkPolyData:
|
| AddCellReference(...)
| AddCellReference(self, cellId:int) -> None
| C++: void AddCellReference(vtkIdType cellId)
|
| Add references to cell in cell structure. This means the links
| from the cell's points to the cell are modified. Memory is not
| extended. Use the method ResizeCellList() to resize the link list
| from a point to its using cells. (This operator assumes
| BuildLinks() has been called.) Use this method only when the
| dataset is set as Editable.
|
| AddReferenceToCell(...)
| AddReferenceToCell(self, ptId:int, cellId:int) -> None
| C++: void AddReferenceToCell(vtkIdType ptId, vtkIdType cellId)
|
| Add a reference to a cell in a particular point's link list. (You
| may also consider using AddCellReference() to add the references
| from all the cell's points to the cell.) This operator does not
| realloc memory; use the operator ResizeCellList() to do this if
| necessary. Use this method only when the dataset is set as
| Editable.
|
| Allocate(...)
| Allocate(self, numCells:int=1000, extSize:int=1000) -> None
| C++: void Allocate(vtkIdType numCells=1000, int extSize=1000)
| Allocate(self, inPolyData:vtkPolyData, numCells:int=1000,
| extSize:int=1000) -> None
| C++: void Allocate(vtkPolyData *inPolyData,
| vtkIdType numCells=1000, int extSize=1000)
|
| Method allocates initial storage for vertex, line, polygon, and
| triangle strip arrays. Use this method before the method
| PolyData::InsertNextCell(). (Or, provide vertex, line, polygon,
| and triangle strip cell arrays). extSize is no longer used.
|
| AllocateCopy(...)
| AllocateCopy(self, pd:vtkPolyData) -> bool
| C++: bool AllocateCopy(vtkPolyData *pd)
|
| Preallocate memory for the internal cell arrays such that they
| are the same size as those in pd.
|
| Existing data is not preserved and the number of cells is set to
| zero.
|
| @return True if allocation succeeds.
|
| AllocateEstimate(...)
| AllocateEstimate(self, numCells:int, maxCellSize:int) -> bool
| C++: bool AllocateEstimate(vtkIdType numCells,
| vtkIdType maxCellSize)
| AllocateEstimate(self, numVerts:int, maxVertSize:int,
| numLines:int, maxLineSize:int, numPolys:int, maxPolySize:int,
| numStrips:int, maxStripSize:int) -> bool
| C++: bool AllocateEstimate(vtkIdType numVerts,
| vtkIdType maxVertSize, vtkIdType numLines,
| vtkIdType maxLineSize, vtkIdType numPolys,
| vtkIdType maxPolySize, vtkIdType numStrips,
| vtkIdType maxStripSize)
|
| Preallocate memory for the internal cell arrays. Each of the
| internal cell arrays (verts, lines, polys, and strips) will be
| resized to holdnumCells cells of size maxCellSize.
|
| Existing data is not preserved and the number of cells is set to
| zero.
|
| @return True if allocation succeeds.
|
| AllocateExact(...)
| AllocateExact(self, numCells:int, connectivitySize:int) -> bool
| C++: bool AllocateExact(vtkIdType numCells,
| vtkIdType connectivitySize)
| AllocateExact(self, numVerts:int, vertConnSize:int, numLines:int,
| lineConnSize:int, numPolys:int, polyConnSize:int,
| numStrips:int, stripConnSize:int) -> bool
| C++: bool AllocateExact(vtkIdType numVerts,
| vtkIdType vertConnSize, vtkIdType numLines,
| vtkIdType lineConnSize, vtkIdType numPolys,
| vtkIdType polyConnSize, vtkIdType numStrips,
| vtkIdType stripConnSize)
|
| Preallocate memory for the internal cell arrays. Each of the
| internal cell arrays (verts, lines, polys, and strips) will be
| resized to holdnumCells cells and connectivitySize pointIds.
|
| Existing data is not preserved and the number of cells is set to
| zero.
|
| @return True if allocation succeeds.
|
| AllocateProportional(...)
| AllocateProportional(self, pd:vtkPolyData, ratio:float) -> bool
| C++: bool AllocateProportional(vtkPolyData *pd, double ratio)
|
| Preallocate memory for the internal cell arrays such that they
| are proportional to those in pd by a factor of ratio (for
| instance,ratio = 2 allocates twice as many cells).
|
| Existing data is not preserved and the number of cells is set to
| zero.
|
| @return True if allocation succeeds.
|
| BuildCells(...)
| BuildCells(self) -> None
| C++: void BuildCells()
|
| Create data structure that allows random access of cells.
| BuildCells is expensive but necessary to make use of the faster
| non-virtual implementations of GetCell/GetCellPoints. One may
| check if cells need to be built via NeedToBuilds before invoking.
| Cells always need to be built/re-built after low level direct
| modifications to verts, lines, polys or strips cell arrays.
|
| BuildLinks(...)
| BuildLinks(self, initialSize:int=0) -> None
| C++: void BuildLinks(int initialSize=0)
|
| Create upward links from points to cells that use each point.
| Enables topologically complex queries. Normally the links array
| is allocated based on the number of points in the vtkPolyData.
| The optional initialSize parameter can be used to allocate a
| larger size initially.
|
| ComputeCellsBounds(...)
| ComputeCellsBounds(self) -> None
| C++: void ComputeCellsBounds()
|
| Compute the (X, Y, Z) bounds of the data. Note that the method
| only considers points that are used by cells. This is done for
| usability and historical reasons.
|
| IMPORTANT
|
| Until vtk 9.0.1, vtkPolyData::ComputeBounds() used to ignore
| points that do not belong to any cell. That was not consistent
| with other vtkPointSet subclasses and thus was error prone. See
| this ParaView issue
| https://gitlab.kitware.com/paraview/paraview/-/issues/20354 Now
| it defers to vtkPointSet::ComputeBounds() so
| vtkPolyData::GetBounds() may not return the same bounds as
| before. This behavior is probably the one you want when using
| bounds.
|
| The previous behavior is still available through
| vtkPolyData::ComputeCellsBounds() and
| vtkPolyData::GetCellsBounds(). This is mainly used for rendering
| purpose.
|
| CopyCells(...)
| CopyCells(self, pd:vtkPolyData, idList:vtkIdList,
| locator:vtkIncrementalPointLocator=...) -> None
| C++: void CopyCells(vtkPolyData *pd, vtkIdList *idList,
| vtkIncrementalPointLocator *locator=nullptr)
|
| Copy cells listed in idList from pd, including points, point
| data, and cell data. This method assumes that point and cell
| data have been allocated. If you pass in a point locator, then
| the points won't be duplicated in the output. This requires the
| use of an incremental point locator.
|
| CopyStructure(...)
| CopyStructure(self, ds:vtkDataSet) -> None
| C++: void CopyStructure(vtkDataSet *ds) override;
|
| Copy the geometric and topological structure of an input poly
| data object.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| DeleteCell(...)
| DeleteCell(self, cellId:int) -> None
| C++: void DeleteCell(vtkIdType cellId)
|
| DeleteCells(...)
| DeleteCells(self) -> None
| C++: void DeleteCells()
|
| Release data structure that allows random access of the cells.
| This must be done before a 2nd call to BuildLinks(). DeleteCells
| implicitly deletes the links as well since they are no longer
| valid.
|
| DeleteLinks(...)
| DeleteLinks(self) -> None
| C++: void DeleteLinks()
|
| Release the upward links from point to cells that use each point.
|
| DeletePoint(...)
| DeletePoint(self, ptId:int) -> None
| C++: void DeletePoint(vtkIdType ptId)
|
| Mark a point/cell as deleted from this vtkPolyData. Use this
| method only when the dataset is set as Editable.
|
| ExtendedNew(...)
| ExtendedNew() -> vtkPolyData
| C++: static vtkPolyData *ExtendedNew()
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated. The
| memory size returned is guaranteed to be greater than or equal to
| the memory required to represent the data (e.g., extra space in
| arrays, etc. are not included in the return value). THIS METHOD
| IS THREAD SAFE.
|
| GetCell(...)
| GetCell(self, cellId:int) -> vtkCell
| C++: vtkCell *GetCell(vtkIdType cellId) override;
| GetCell(self, cellId:int, cell:vtkGenericCell) -> None
| C++: void GetCell(vtkIdType cellId, vtkGenericCell *cell)
| override;
| GetCell(self, cellId:int, pts:(int, ...)) -> int
| C++: unsigned char GetCell(vtkIdType cellId,
| const vtkIdType *&pts)
| GetCell(self, i:int, j:int, k:int) -> vtkCell
| C++: virtual vtkCell *GetCell(int i, int j, int k)
|
| This method always return a `vtkEmptyCell`, as there is no cell
| in a `vtkPointSet`.
|
| GetCellBounds(...)
| GetCellBounds(self, cellId:int, bounds:[float, float, float,
| float, float, float]) -> None
| C++: void GetCellBounds(vtkIdType cellId, double bounds[6])
| override;
|
| Get the bounds of the cell with cellId such that: 0 <= cellId <
| NumberOfCells. A subclass may be able to determine the bounds of
| cell without using an expensive GetCell() method. A default
| implementation is provided that actually uses a GetCell() call.
| This is to ensure the method is available to all datasets.
| Subclasses should override this method to provide an efficient
| implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetCellEdgeNeighbors(...)
| GetCellEdgeNeighbors(self, cellId:int, p1:int, p2:int,
| cellIds:vtkIdList) -> None
| C++: void GetCellEdgeNeighbors(vtkIdType cellId, vtkIdType p1,
| vtkIdType p2, vtkIdList *cellIds)
|
| Get the neighbors at an edge. More efficient than the general
| GetCellNeighbors(). Assumes links have been built (with
| BuildLinks()), and looks specifically for edge neighbors.
|
| GetCellIdRelativeToCellArray(...)
| GetCellIdRelativeToCellArray(self, cellId:int) -> int
| C++: vtkIdType GetCellIdRelativeToCellArray(vtkIdType cellId)
|
| Maps the cell at position `cellId` inside the `vtkPolyData` to
| its location in the corresponding cell array. For instance, if
| cell `cellId` is a line, then this method returns the position of
| this cell in the `Lines` cell array.
|
| GetCellNeighbors(...)
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds) override;
|
| Topological inquiry to get all cells using list of points
| exclusive of cell specified (e.g., cellId). Note that the list
| consists of only cells that use ALL the points provided. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetCellPoints(...)
| GetCellPoints(self, cellId:int, ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
| override;
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...)) -> int
| C++: unsigned char GetCellPoints(vtkIdType cellId,
| vtkIdType &npts, vtkIdType const *&pts)
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...),
| ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts, vtkIdList *ptIds) override;
|
| Copy a cells point ids into list provided. (Less efficient.)
|
| GetCellSize(...)
| GetCellSize(self, cellId:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType cellId) override;
|
| This method always returns 1, as all cells are point in a pure
| `vtkPointSet`.
|
| GetCellType(...)
| GetCellType(self, cellId:int) -> int
| C++: int GetCellType(vtkIdType cellId) override;
|
| This method always returns `VTK_EMPTY_CELL`, as there is no cell
| in a `vtkPointSet`.
|
| GetCellsBounds(...)
| GetCellsBounds(self, bounds:[float, float, float, float, float,
| float]) -> None
| C++: void GetCellsBounds(double bounds[6])
|
| Get the cells bounds. Internally calls ComputeCellsBounds().
| @sa ComputeCellsBounds()
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkPolyData
| C++: static vtkPolyData *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkPolyData
| C++: static vtkPolyData *GetData(vtkInformationVector *v, int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return what type of dataset this is.
|
| GetGhostLevel(...)
| GetGhostLevel(self) -> int
| C++: virtual int GetGhostLevel()
|
| Get the ghost level.
|
| GetLines(...)
| GetLines(self) -> vtkCellArray
| C++: vtkCellArray *GetLines()
|
| Get the cell array defining lines. If there are no lines, an
| empty array will be returned (convenience to simplify traversal).
|
| GetLinks(...)
| GetLinks(self) -> vtkAbstractCellLinks
| C++: virtual vtkAbstractCellLinks *GetLinks()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Get MTime which also considers its cell array MTime.
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Return the maximum cell size in this poly data.
|
| GetMaxSpatialDimension(...)
| GetMaxSpatialDimension(self) -> int
| C++: int GetMaxSpatialDimension() override;
|
| Get the maximum/minimum spatial dimensionality of the data which
| is the maximum/minimum dimension of all cells.
|
| GetMeshMTime(...)
| GetMeshMTime(self) -> int
| C++: vtkMTimeType GetMeshMTime() override;
|
| Return the mesh (geometry/topology) modification time. This time
| is different from the usual MTime which also takes into account
| the modification of data arrays. This function can be used to
| track the changes on the mesh separately from the data arrays
| (eg. static mesh over time with transient data).
|
| GetMinSpatialDimension(...)
| GetMinSpatialDimension(self) -> int
| C++: int GetMinSpatialDimension() override;
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| Standard vtkDataSet interface.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfLines(...)
| GetNumberOfLines(self) -> int
| C++: vtkIdType GetNumberOfLines()
|
| GetNumberOfPieces(...)
| GetNumberOfPieces(self) -> int
| C++: virtual int GetNumberOfPieces()
|
| GetNumberOfPolys(...)
| GetNumberOfPolys(self) -> int
| C++: vtkIdType GetNumberOfPolys()
|
| GetNumberOfStrips(...)
| GetNumberOfStrips(self) -> int
| C++: vtkIdType GetNumberOfStrips()
|
| GetNumberOfVerts(...)
| GetNumberOfVerts(self) -> int
| C++: vtkIdType GetNumberOfVerts()
|
| Return the number of primitives of a particular type held.
|
| GetPiece(...)
| GetPiece(self) -> int
| C++: virtual int GetPiece()
|
| Get the piece and the number of pieces. Similar to extent in 3D.
|
| GetPointCells(...)
| GetPointCells(self, ptId:int, cellIds:vtkIdList) -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
| override;
| GetPointCells(self, ptId:int, ncells:int, cells:[int, ...])
| -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdType &ncells,
| vtkIdType *&cells)
|
| Efficient method to obtain cells using a particular point. Make
| sure that routine BuildLinks() has been called.
|
| GetPolys(...)
| GetPolys(self) -> vtkCellArray
| C++: vtkCellArray *GetPolys()
|
| Get the cell array defining polygons. If there are no polygons,
| an empty array will be returned (convenience to simplify
| traversal).
|
| GetScalarFieldCriticalIndex(...)
| GetScalarFieldCriticalIndex(self, pointId:int,
| scalarField:vtkDataArray) -> int
| C++: int GetScalarFieldCriticalIndex(vtkIdType pointId,
| vtkDataArray *scalarField)
| GetScalarFieldCriticalIndex(self, pointId:int, fieldId:int) -> int
| C++: int GetScalarFieldCriticalIndex(vtkIdType pointId,
| int fieldId)
| GetScalarFieldCriticalIndex(self, pointId:int, fieldName:str)
| -> int
| C++: int GetScalarFieldCriticalIndex(vtkIdType pointId,
| const char *fieldName)
|
| GetStrips(...)
| GetStrips(self) -> vtkCellArray
| C++: vtkCellArray *GetStrips()
|
| Get the cell array defining triangle strips. If there are no
| triangle strips, an empty array will be returned (convenience to
| simplify traversal).
|
| GetVerts(...)
| GetVerts(self) -> vtkCellArray
| C++: vtkCellArray *GetVerts()
|
| Get the cell array defining vertices. If there are no vertices,
| an empty array will be returned (convenience to simplify
| traversal).
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Restore object to initial state. Release memory back to system.
|
| InsertNextCell(...)
| InsertNextCell(self, type:int, npts:int, pts:(int, ...)) -> int
| C++: vtkIdType InsertNextCell(int type, int npts,
| const vtkIdType pts[])
| InsertNextCell(self, type:int, pts:vtkIdList) -> int
| C++: vtkIdType InsertNextCell(int type, vtkIdList *pts)
|
| Insert a cell of type VTK_VERTEX, VTK_POLY_VERTEX, VTK_LINE,
| VTK_POLY_LINE, VTK_TRIANGLE, VTK_QUAD, VTK_POLYGON, or
| VTK_TRIANGLE_STRIP. Make sure that the PolyData::Allocate()
| function has been called first or that vertex, line, polygon, and
| triangle strip arrays have been supplied. Note: will also insert
| VTK_PIXEL, but converts it to VTK_QUAD.
|
| InsertNextLinkedCell(...)
| InsertNextLinkedCell(self, type:int, npts:int, pts:(int, ...))
| -> int
| C++: vtkIdType InsertNextLinkedCell(int type, int npts,
| const vtkIdType pts[])
|
| Add a new cell to the cell data structure (after cell pointers
| have been built). This method adds the cell and then updates the
| links from the points to the cells. (Memory is allocated as
| necessary.) Use this method only when the dataset is set as
| Editable.
|
| InsertNextLinkedPoint(...)
| InsertNextLinkedPoint(self, numLinks:int) -> int
| C++: vtkIdType InsertNextLinkedPoint(int numLinks)
| InsertNextLinkedPoint(self, x:[float, float, float], numLinks:int)
| -> int
| C++: vtkIdType InsertNextLinkedPoint(double x[3], int numLinks)
|
| Add a point to the cell data structure (after cell pointers have
| been built). This method adds the point and then allocates memory
| for the links to the cells. (To use this method, make sure
| points are available and BuildLinks() has been invoked.) Of the
| two methods below, one inserts a point coordinate and the other
| just makes room for cell links. Use this method only when the
| dataset is set as Editable.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsEdge(...)
| IsEdge(self, p1:int, p2:int) -> int
| C++: int IsEdge(vtkIdType p1, vtkIdType p2)
|
| Determine whether two points form an edge. If they do, return
| non-zero. By definition PolyVertex and PolyLine have no edges
| since 1-dimensional edges are only found on cells 2D and higher.
| Edges are defined as 1-D boundary entities to cells. Make sure
| BuildLinks() has been called first.
|
| IsPointUsedByCell(...)
| IsPointUsedByCell(self, ptId:int, cellId:int) -> int
| C++: int IsPointUsedByCell(vtkIdType ptId, vtkIdType cellId)
|
| Determine whether a point is used by a particular cell. If it is,
| return non-zero. Make sure BuildCells() has been called first.
|
| IsTriangle(...)
| IsTriangle(self, v1:int, v2:int, v3:int) -> int
| C++: int IsTriangle(int v1, int v2, int v3)
|
| Given three vertices, determine whether it's a triangle. Make
| sure BuildLinks() has been called first.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NeedToBuildCells(...)
| NeedToBuildCells(self) -> bool
| C++: bool NeedToBuildCells()
|
| Check if BuildCells is needed.
|
| NewInstance(...)
| NewInstance(self) -> vtkPolyData
| C++: vtkPolyData *NewInstance()
|
| RemoveCellReference(...)
| RemoveCellReference(self, cellId:int) -> None
| C++: void RemoveCellReference(vtkIdType cellId)
|
| Remove all references to cell in cell structure. This means the
| links from the cell's points to the cell are deleted. Memory is
| not reclaimed. Use the method ResizeCellList() to resize the link
| list from a point to its using cells. (This operator assumes
| BuildLinks() has been called.) Use this method only when the
| dataset is set as Editable.
|
| RemoveDeletedCells(...)
| RemoveDeletedCells(self) -> None
| C++: void RemoveDeletedCells()
|
| The cells marked by calls to DeleteCell are stored in the Cell
| Array VTK_EMPTY_CELL, but they still exist in the cell arrays.
| Calling RemoveDeletedCells will traverse the cell arrays and
| remove/compact the cell arrays as well as any cell data thus
| truly removing the cells from the polydata object. Use this
| method only when the dataset is set as Editable.
|
| RemoveGhostCells(...)
| RemoveGhostCells(self) -> None
| C++: void RemoveGhostCells()
|
| This method will remove any cell that is marked as ghost (has the
| vtkDataSetAttributes::DUPLICATECELL or the
| vtkDataSetAttributes::HIDDENCELL bit set). It does not remove
| unused points.
|
| RemoveReferenceToCell(...)
| RemoveReferenceToCell(self, ptId:int, cellId:int) -> None
| C++: void RemoveReferenceToCell(vtkIdType ptId, vtkIdType cellId)
|
| Remove a reference to a cell in a particular point's link list.
| You may also consider using RemoveCellReference() to remove the
| references from all the cell's points to the cell. This operator
| does not reallocate memory; use the operator ResizeCellList() to
| do this if necessary. Use this method only when the dataset is
| set as Editable.
|
| ReplaceCell(...)
| ReplaceCell(self, cellId:int, ids:vtkIdList) -> None
| C++: void ReplaceCell(vtkIdType cellId, vtkIdList *ids)
| ReplaceCell(self, cellId:int, npts:int, pts:(int, ...)) -> None
| C++: void ReplaceCell(vtkIdType cellId, int npts,
| const vtkIdType pts[])
|
| ReplaceCellPoint(...)
| ReplaceCellPoint(self, cellId:int, oldPtId:int, newPtId:int)
| -> None
| C++: void ReplaceCellPoint(vtkIdType cellId, vtkIdType oldPtId,
| vtkIdType newPtId)
| ReplaceCellPoint(self, cellId:int, oldPtId:int, newPtId:int,
| cellPointIds:vtkIdList) -> None
| C++: void ReplaceCellPoint(vtkIdType cellId, vtkIdType oldPtId,
| vtkIdType newPtId, vtkIdList *cellPointIds)
|
| Replace a point in the cell connectivity list with a different
| point. Use this method only when the dataset is set as Editable.
|
| The version with cellPointIds avoids allocating/deallocating a
| vtkIdList at each call internally.
|
| THIS METHOD IS THREAD SAFE IF BuildCells() IS FIRST CALLED FROM A
| SINGLE THREAD.
|
| ReplaceLinkedCell(...)
| ReplaceLinkedCell(self, cellId:int, npts:int, pts:(int, ...))
| -> None
| C++: void ReplaceLinkedCell(vtkIdType cellId, int npts,
| const vtkIdType pts[])
|
| Replace one cell with another in cell structure. This operator
| updates the connectivity list and the point's link list. It does
| not delete references to the old cell in the point's link list.
| Use the operator RemoveCellReference() to delete all references
| from points to (old) cell. You may also want to consider using
| the operator ResizeCellList() if the link list is changing size.
| Use this method only when the dataset is set as Editable.
|
| Reset(...)
| Reset(self) -> None
| C++: void Reset()
|
| Begin inserting data all over again. Memory is not freed but
| otherwise objects are returned to their initial state.
|
| ResizeCellList(...)
| ResizeCellList(self, ptId:int, size:int) -> None
| C++: void ResizeCellList(vtkIdType ptId, int size)
|
| Resize the list of cells using a particular point. (This operator
| assumes that BuildLinks() has been called.) Use this method only
| when the dataset is set as Editable.
|
| ReverseCell(...)
| ReverseCell(self, cellId:int) -> None
| C++: void ReverseCell(vtkIdType cellId)
|
| Reverse the order of point ids defining the cell. Use this method
| only when the dataset is set as Editable.
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkPolyData
| C++: static vtkPolyData *SafeDownCast(vtkObjectBase *o)
|
| SetLines(...)
| SetLines(self, l:vtkCellArray) -> None
| C++: void SetLines(vtkCellArray *l)
|
| Set the cell array defining lines.
|
| SetLinks(...)
| SetLinks(self, _arg:vtkAbstractCellLinks) -> None
| C++: virtual void SetLinks(vtkAbstractCellLinks *_arg)
|
| Set/Get the links that were created possibly without using
| BuildLinks.
|
| SetPolys(...)
| SetPolys(self, p:vtkCellArray) -> None
| C++: void SetPolys(vtkCellArray *p)
|
| Set the cell array defining polygons.
|
| SetStrips(...)
| SetStrips(self, s:vtkCellArray) -> None
| C++: void SetStrips(vtkCellArray *s)
|
| Set the cell array defining triangle strips.
|
| SetVerts(...)
| SetVerts(self, v:vtkCellArray) -> None
| C++: void SetVerts(vtkCellArray *v)
|
| Set the cell array defining vertices.
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: void Squeeze() override;
|
| Recover extra allocated memory when creating data whose initial
| size is unknown. Examples include using the InsertNextCell()
| method, or when using the CellArray::EstimateSize() method to
| create vertices, lines, polygons, or triangle strips.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkPolyData:
|
| __this__
| Pointer to the C++ object.
|
| data_object_type
| read-only, calls GetDataObjectType
|
| ghost_level
| read-only, calls GetGhostLevel
|
| links
| read-write, calls GetLinks/SetLinks
|
| m_time
| read-only, calls GetMTime
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| max_spatial_dimension
| read-only, calls GetMaxSpatialDimension
|
| mesh_m_time
| read-only, calls GetMeshMTime
|
| min_spatial_dimension
| read-only, calls GetMinSpatialDimension
|
| number_of_lines
| read-only, calls GetNumberOfLines
|
| number_of_pieces
| read-only, calls GetNumberOfPieces
|
| number_of_polys
| read-only, calls GetNumberOfPolys
|
| number_of_strips
| read-only, calls GetNumberOfStrips
|
| number_of_verts
| read-only, calls GetNumberOfVerts
|
| piece
| read-only, calls GetPiece
|
| polys
| read-write, calls GetPolys/SetPolys
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkPolyData:
|
| ERR_INCORRECT_FIELD = -3
|
| ERR_NON_MANIFOLD_STAR = -2
|
| ERR_NO_SUCH_FIELD = -4
|
| MAXIMUM = 2
|
| MINIMUM = 0
|
| REGULAR_POINT = -1
|
| SADDLE = 1
|
| __vtkname__ = 'vtkPolyData'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| BuildCellLocator(...)
| BuildCellLocator(self) -> None
| C++: void BuildCellLocator()
|
| Build the cell locator. In a multi-threaded environment, call
| this method in a single thread before using FindCell().
|
| BuildLocator(...)
| BuildLocator(self) -> None
| C++: void BuildLocator()
|
| BuildPointLocator(...)
| BuildPointLocator(self) -> None
| C++: void BuildPointLocator()
|
| Build the internal point locator . In a multi-threaded
| environment, call this method in a single thread before using
| FindCell() or FindPoint().
|
| ComputeBounds(...)
| ComputeBounds(self) -> None
| C++: void ComputeBounds() override;
|
| Compute the (X, Y, Z) bounds of the data.
|
| EditableOff(...)
| EditableOff(self) -> None
| C++: virtual void EditableOff()
|
| EditableOn(...)
| EditableOn(self) -> None
| C++: virtual void EditableOn()
|
| FindCell(...)
| FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int,
| tol2:float, subId:int, pcoords:[float, float, float],
| weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
| FindCell(self, x:[float, float, float], cell:vtkCell,
| gencell:vtkGenericCell, cellId:int, tol2:float, subId:int,
| pcoords:[float, float, float], weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkGenericCell *gencell, vtkIdType cellId, double tol2,
| int &subId, double pcoords[3], double *weights) override;
|
| Locate cell based on global coordinate x and tolerance squared.
| If cell and cellId is non-nullptr, then search starts from this
| cell and looks at immediate neighbors. Returns cellId >= 0 if
| inside, < 0 otherwise. The parametric coordinates are provided
| in pcoords[3]. The interpolation weights are returned in
| weights[]. (The number of weights is equal to the number of
| points in the found cell). Tolerance is used to control how close
| the point is to be considered "in" the cell. THIS METHOD IS NOT
| THREAD SAFE.
|
| FindPoint(...)
| FindPoint(self, x:[float, float, float]) -> int
| C++: vtkIdType FindPoint(double x[3]) override;
|
| GetCellLocator(...)
| GetCellLocator(self) -> vtkAbstractCellLocator
| C++: virtual vtkAbstractCellLocator *GetCellLocator()
|
| GetEditable(...)
| GetEditable(self) -> bool
| C++: virtual bool GetEditable()
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| See vtkDataSet for additional information.
|
| GetPoint(...)
| GetPoint(self, ptId:int, x:[float, float, float]) -> None
| C++: void GetPoint(vtkIdType ptId, double x[3]) override;
| GetPoint(self, ptId:int) -> (float, float, float)
| C++: double *GetPoint(vtkIdType ptId) override;
|
| Copy point coordinates into user provided array x[3] for
| specified point id. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetPointLocator(...)
| GetPointLocator(self) -> vtkAbstractPointLocator
| C++: virtual vtkAbstractPointLocator *GetPointLocator()
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints() override;
|
| If the subclass has (implicit/explicit) points, then return them.
| Otherwise, create a vtkPoints object and return that.
|
| DO NOT MODIFY THE RETURNED POINTS OBJECT.
|
| NewCellIterator(...)
| NewCellIterator(self) -> vtkCellIterator
| C++: vtkCellIterator *NewCellIterator() override;
|
| Return an iterator that traverses the cells in this data set.
|
| SetCellLocator(...)
| SetCellLocator(self, __a:vtkAbstractCellLocator) -> None
| C++: virtual void SetCellLocator(vtkAbstractCellLocator *)
|
| Set / get an instance of vtkAbstractCellLocator which may be used
| when a vtkCellLocatorStrategy is used during a FindCell()
| operation.
|
| SetEditable(...)
| SetEditable(self, _arg:bool) -> None
| C++: virtual void SetEditable(bool _arg)
|
| Specify whether this dataset is editable after creation. Meaning,
| once the points and cells are defined, can the dataset be
| incrementally modified. By default, this dataset is non-editable
| (i.e., "static") after construction. The reason for this is
| performance: cell links and locators can be built (and destroyed)
| much faster is it is known that the data is static (see
| vtkStaticCellLinks, vtkStaticPointLocator, vtkStaticCellLocator).
|
| SetPointLocator(...)
| SetPointLocator(self, __a:vtkAbstractPointLocator) -> None
| C++: virtual void SetPointLocator(vtkAbstractPointLocator *)
|
| Set / get an instance of vtkAbstractPointLocator which is used to
| support the FindPoint() and FindCell() methods. By default a
| vtkStaticPointLocator is used, unless the class is set as
| Editable, in which case a vtkPointLocator is used.
|
| SetPoints(...)
| SetPoints(self, __a:vtkPoints) -> None
| C++: virtual void SetPoints(vtkPoints *)
|
| Specify point array to define point coordinates.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Overwritten to handle the data/locator loop
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| cell_locator
| read-write, calls GetCellLocator/SetCellLocator
|
| editable
| read-write, calls GetEditable/SetEditable
|
| point_locator
| read-write, calls GetPointLocator/SetPointLocator
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| AllocateCellGhostArray(...)
| AllocateCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocateCellGhostArray()
|
| Allocate ghost array for cells.
|
| AllocatePointGhostArray(...)
| AllocatePointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocatePointGhostArray()
|
| Allocate ghost array for points.
|
| CheckAttributes(...)
| CheckAttributes(self) -> int
| C++: int CheckAttributes()
|
| This method checks to see if the cell and point attributes match
| the geometry. Many filters will crash if the number of tuples in
| an array is less than the number of points/cells. This method
| returns 1 if there is a mismatch, and 0 if everything is ok. It
| prints an error if an array is too short, and a warning if an
| array is too long.
|
| CopyAttributes(...)
| CopyAttributes(self, ds:vtkDataSet) -> None
| C++: virtual void CopyAttributes(vtkDataSet *ds)
|
| Copy the attributes associated with the specified dataset to this
| instance of vtkDataSet. THIS METHOD IS NOT THREAD SAFE.
|
| FindAndGetCell(...)
| FindAndGetCell(self, x:[float, float, float], cell:vtkCell,
| cellId:int, tol2:float, subId:int, pcoords:[float, float,
| float], weights:[float, ...]) -> vtkCell
| C++: virtual vtkCell *FindAndGetCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights)
|
| Locate the cell that contains a point and return the cell. Also
| returns the subcell id, parametric coordinates and weights for
| subsequent interpolation. This method combines the derived class
| methods int FindCell and vtkCell *GetCell. Derived classes may
| provide a more efficient implementation. See for example
| vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE.
|
| GenerateGhostArray(...)
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int])
| -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6])
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int],
| cellOnly:bool) -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6],
| bool cellOnly)
|
| Normally called by pipeline executives or algorithms only. This
| method computes the ghost arrays for a given dataset. The zeroExt
| argument specifies the extent of the region which ghost type = 0.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return a pointer to the geometry bounding box in the form
| (xmin,xmax, ymin,ymax, zmin,zmax). THIS METHOD IS NOT THREAD
| SAFE.
|
| GetCellData(...)
| GetCellData(self) -> vtkCellData
| C++: vtkCellData *GetCellData()
|
| Return a pointer to this dataset's cell data. THIS METHOD IS
| THREAD SAFE
|
| GetCellGhostArray(...)
| GetCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellGhostArray()
|
| Get the array that defines the ghost type of each cell. We cache
| the pointer to the array to save a lookup involving string
| comparisons
|
| GetCellNumberOfFaces(...)
| GetCellNumberOfFaces(self, cellId:int, cellType:int,
| cell:vtkGenericCell) -> int
| C++: virtual int GetCellNumberOfFaces(vtkIdType cellId,
| unsigned char &cellType, vtkGenericCell *cell)
|
| Get the number of faces of a cell.
|
| Most of the times extracting the number of faces requires only
| extracting the cell type. However, for some cell types, the
| number of faces is not constant. For example, a convex point set
| cell can have a different number of faces for each cell. That's
| why this method requires the cell id and the dataset.
|
| GetCellTypes(...)
| GetCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetCellTypes(vtkCellTypes *types)
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: double *GetCenter()
| GetCenter(self, center:[float, float, float]) -> None
| C++: void GetCenter(double center[3])
|
| Get the center of the bounding box. THIS METHOD IS NOT THREAD
| SAFE.
|
| GetDistinctCellTypes(...)
| GetDistinctCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetDistinctCellTypes(vtkCellTypes *types)
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset 5 triangles, 3 lines, and
| 100 hexahedra would result a list of three entries, corresponding
| to the types VTK_TRIANGLE, VTK_LINE, and VTK_HEXAHEDRON. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetGhostArray(int type) override;
|
| Returns the ghost array for the given type (point or cell). Takes
| advantage of the cache with the pointer to the array to save a
| string comparison.
|
| GetLength(...)
| GetLength(self) -> float
| C++: double GetLength()
|
| Return the length of the diagonal of the bounding box. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Return the squared length of the diagonal of the bounding box.
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| GetPointData(...)
| GetPointData(self) -> vtkPointData
| C++: vtkPointData *GetPointData()
|
| Return a pointer to this dataset's point data. THIS METHOD IS
| THREAD SAFE
|
| GetPointGhostArray(...)
| GetPointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetPointGhostArray()
|
| Gets the array that defines the ghost type of each point. We
| cache the pointer to the array to save a lookup involving string
| comparisons
|
| GetScalarRange(...)
| GetScalarRange(self, range:[float, float]) -> None
| C++: virtual void GetScalarRange(double range[2])
| GetScalarRange(self) -> (float, float)
| C++: double *GetScalarRange()
|
| Convenience method to get the range of the first component (and
| only the first component) of any scalars in the data set. If the
| data has both point data and cell data, it returns the (min/max)
| range of combined point and cell data. If there are no point or
| cell scalars the method will return (0,1). Note: It might be
| necessary to call Update to create or refresh the scalars before
| calling this method. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| HasAnyBlankCells(...)
| HasAnyBlankCells(self) -> bool
| C++: virtual bool HasAnyBlankCells()
|
| Returns 1 if there are any blanking cells 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyBlankPoints(...)
| HasAnyBlankPoints(self) -> bool
| C++: virtual bool HasAnyBlankPoints()
|
| Returns 1 if there are any blanking points 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyGhostCells(...)
| HasAnyGhostCells(self) -> bool
| C++: bool HasAnyGhostCells()
|
| Returns 1 if there are any ghost cells 0 otherwise.
|
| HasAnyGhostPoints(...)
| HasAnyGhostPoints(self) -> bool
| C++: bool HasAnyGhostPoints()
|
| Returns 1 if there are any ghost points 0 otherwise.
|
| SetCellOrderAndRationalWeights(...)
| SetCellOrderAndRationalWeights(self, cellId:int,
| cell:vtkGenericCell) -> None
| C++: void SetCellOrderAndRationalWeights(vtkIdType cellId,
| vtkGenericCell *cell)
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| cell_ghost_array
| read-only, calls GetCellGhostArray
|
| length2
| read-only, calls GetLength2
|
| point_ghost_array
| read-only, calls GetPointGhostArray
|
| scalar_range
| read-only, calls GetScalarRange
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| CELL_DATA_FIELD = 2
|
| DATA_OBJECT_FIELD = 0
|
| FieldDataType = <class 'vtkmodules.vtkCommonDataModel.vtkDataSet.Field...
|
| POINT_DATA_FIELD = 1
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: virtual void Crop(const int *updateExtent)
|
| This method crops the data object (if necessary) so that the
| extent matches the update extent.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: virtual int GetExtentType()
|
| The ExtentType will be left as VTK_PIECES_EXTENT for data objects
| such as vtkPolyData and vtkUnstructuredGrid. The ExtentType will
| be changed to VTK_3D_EXTENT for data objects with 3D structure
| such as vtkImageData (and its subclass vtkStructuredPoints),
| vtkRectilinearGrid, and vtkStructuredGrid. The default is the
| have an extent in pieces, with only one piece (no streaming
| possible).
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| extent_type
| read-only, calls GetExtentType
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.PolyDataFilters
Python Library Documentation: class PolyDataFilters in module pyvista.core.filters.poly_data
class PolyDataFilters(pyvista.core.filters.data_set.DataSetFilters)
| PolyDataFilters(*args, **kwargs)
|
| An internal class to manage filters/algorithms for polydata datasets.
|
| Method resolution order:
| PolyDataFilters
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| builtins.object
|
| Methods defined here:
|
| __add__(self: 'PolyData', dataset)
| Merge these two meshes.
|
| __iadd__(self: 'PolyData', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``dataset`` is also a :class:`PolyData`.
| Otherwise we have to return a :class:`pyvista.UnstructuredGrid`,
| so the in-place merge attempt will raise.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| append_polydata(self, *meshes, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Append one or more PolyData into this one.
|
| Under the hood, the VTK :vtk:`vtkAppendPolyData`
| filter is used to perform the append operation.
|
| .. versionadded:: 0.40.0
|
| .. note::
| As stated in the VTK documentation of :vtk:`vtkAppendPolyData`,
| point and cell data are added to the output PolyData **only** if they
| are present across **all** input PolyData.
|
| .. seealso::
| :func:`pyvista.PolyDataFilters.merge`
|
| Parameters
| ----------
| *meshes : list[pyvista.PolyData]
| The PolyData(s) to append with the current one.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Appended PolyData(s).
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sp0 = pv.Sphere()
| >>> sp1 = sp0.translate((1, 0, 0))
| >>> appended = sp0.append_polydata(sp1)
| >>> appended.plot()
|
| Append more than one PolyData.
|
| >>> sp2 = sp0.translate((-1, 0, 0))
| >>> appended = sp0.append_polydata(sp1, sp2)
| >>> appended.plot()
|
| boolean_difference(self, other_mesh, tolerance=1e-05, progress_bar: 'bool' = False)
| Perform a boolean difference operation between two meshes.
|
| Essentially, boolean union, difference, and intersection are
| all the same operation. Just different parts of the objects
| are kept at the end.
|
| The difference of two manifold meshes ``A`` and ``B`` is the
| volume of the mesh in ``A`` not belonging to ``B``.
|
| .. note::
| If your boolean operations don't react the way you think they
| should (i.e. the wrong parts disappear), one of your meshes
| probably has its normals pointing inward. Use
| :func:`PolyDataFilters.plot_normals` to visualize the
| normals.
|
| .. note::
| Both meshes must be composed of all triangles. Check with
| :attr:`PolyData.is_all_triangles` and convert with
| :func:`PolyDataFilters.triangulate`.
|
| .. versionchanged:: 0.32.0
| Behavior changed to match default VTK behavior.
|
| Parameters
| ----------
| other_mesh : pyvista.PolyData
| Mesh operating on the source mesh.
|
| tolerance : float, default: 1e-5
| Tolerance used to determine when a point's absolute
| distance is considered to be zero.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The result of the boolean operation.
|
| Examples
| --------
| Demonstrate a boolean difference with two spheres. Note how
| the final mesh only includes ``sphere_a``.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> result = sphere_a - sphere_b
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere_a, color='r', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(sphere_b, color='b', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(result, color='lightblue')
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| boolean_intersection(self, other_mesh, tolerance=1e-05, progress_bar: 'bool' = False)
| Perform a boolean intersection operation on two meshes.
|
| Essentially, boolean union, difference, and intersection are
| all the same operation. Just different parts of the objects
| are kept at the end.
|
| The intersection of two manifold meshes ``A`` and ``B`` is the mesh
| which is the volume of ``A`` that is also in ``B``.
|
| .. note::
| If your boolean operations don't react the way you think they
| should (i.e. the wrong parts disappear), one of your meshes
| probably has its normals pointing inward. Use
| :func:`PolyDataFilters.plot_normals` to visualize the
| normals.
|
| .. note::
| This method returns the "volume" intersection between two
| meshes whereas the :func:`PolyDataFilters.intersection`
| filter returns the surface intersection between two meshes
| (which often resolves as a line).
|
|
| .. note::
| Both meshes must be composed of all triangles. Check with
| :attr:`PolyData.is_all_triangles` and convert with
| :func:`PolyDataFilters.triangulate`.
|
| .. versionadded:: 0.32.0
|
| .. versionchanged:: 0.45.0
| Define ``&`` operator to perform boolean intersection.
|
| Parameters
| ----------
| other_mesh : pyvista.PolyData
| Mesh operating on the source mesh.
|
| tolerance : float, default: 1e-5
| Tolerance used to determine when a point's absolute
| distance is considered to be zero.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The result of the boolean operation.
|
| Examples
| --------
| Demonstrate a boolean intersection with two spheres. Note how
| the final mesh only includes the intersection of the two.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> result = sphere_a & sphere_b
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere_a, color='r', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(sphere_b, color='b', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(result, color='lightblue')
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| boolean_union(self, other_mesh, tolerance=1e-05, progress_bar: 'bool' = False)
| Perform a boolean union operation on two meshes.
|
| Essentially, boolean union, difference, and intersection are
| all the same operation. Just different parts of the objects
| are kept at the end.
|
| The union of two manifold meshes ``A`` and ``B`` is the mesh
| which is in ``A``, in ``B``, or in both ``A`` and ``B``.
|
| .. note::
| If your boolean operations don't react the way you think they
| should (i.e. the wrong parts disappear), one of your meshes
| probably has its normals pointing inward. Use
| :func:`PolyDataFilters.plot_normals` to visualize the
| normals.
|
| .. note::
| The behavior of this filter varies from the
| :func:`PolyDataFilters.merge` filter. This filter attempts
| to create a manifold mesh and will not include internal
| surfaces when two meshes overlap.
|
| .. note::
| Both meshes must be composed of all triangles. Check with
| :attr:`PolyData.is_all_triangles` and convert with
| :func:`PolyDataFilters.triangulate`.
|
| .. versionchanged:: 0.32.0
| Behavior changed to match default VTK behavior.
|
| .. versionchanged:: 0.45.0
| Define ``|`` operator to perform boolean union.
|
| Parameters
| ----------
| other_mesh : pyvista.PolyData
| Mesh operating on the source mesh.
|
| tolerance : float, tolerance: 1e-5
| Tolerance used to determine when a point's absolute
| distance is considered to be zero.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The result of the boolean operation.
|
| Examples
| --------
| Demonstrate a boolean union with two spheres. Note how the
| final mesh includes both spheres.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> result = sphere_a | sphere_b
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere_a, color='r', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(sphere_b, color='b', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(result, color='lightblue')
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| clean(self, point_merging: 'bool' = True, tolerance=None, lines_to_points: 'bool' = True, polys_to_lines: 'bool' = True, strips_to_polys: 'bool' = True, inplace: 'bool' = False, absolute: 'bool' = True, progress_bar: 'bool' = False, **kwargs)
| Clean the mesh.
|
| This merges duplicate points, removes unused points, and/or
| removes degenerate cells.
|
| Parameters
| ----------
| point_merging : bool, optional
| Enables point merging. ``True`` by default.
|
| tolerance : float, optional
| Set merging tolerance. When enabled merging is set to
| absolute distance. If ``absolute`` is ``False``, then the
| merging tolerance is a fraction of the bounding box
| length. The alias ``merge_tol`` is also excepted.
|
| lines_to_points : bool, optional
| Enable or disable the conversion of degenerate lines to
| points. Enabled by default.
|
| polys_to_lines : bool, optional
| Enable or disable the conversion of degenerate polys to
| lines. Enabled by default.
|
| strips_to_polys : bool, optional
| Enable or disable the conversion of degenerate strips to
| polys.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| absolute : bool, optional
| Control if ``tolerance`` is an absolute distance or a
| fraction.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts for ``merge_tol`` to replace the ``tolerance``
| keyword argument. This may be deprecated in future.
|
| Returns
| -------
| pyvista.PolyData
| Cleaned mesh.
|
| See Also
| --------
| remove_unused_points
| Strictly remove unused points `without` merging points.
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Create a mesh with a degenerate face and then clean it,
| removing the degenerate face
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array([[0, 0, 0], [0, 1, 0], [1, 0, 0]], dtype=np.float32)
| >>> faces = np.array([3, 0, 1, 2, 3, 0, 2, 2])
| >>> mesh = pv.PolyData(points, faces)
| >>> mout = mesh.clean()
| >>> mout.faces # doctest:+SKIP
| array([3, 0, 1, 2])
|
| clip_closed_surface(self: 'PolyData', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, tolerance=1e-06, inplace: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a closed polydata surface with a plane.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| This currently only supports one plane but could be
| implemented to handle a plane collection.
|
| It will produce a new closed surface by creating new polygonal
| faces where the input data was clipped.
|
| Non-manifold surfaces should not be used as input for this
| filter. The input surface should have no open edges, and must
| not have any edges that are shared by more than two faces. In
| addition, the input surface should not self-intersect, meaning
| that the faces of the surface should only touch at their
| edges.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| tolerance : float, optional
| The tolerance for creating new points while clipping. If
| the tolerance is too small, then degenerate triangles
| might be produced.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| The clipped mesh.
|
| Examples
| --------
| Clip a sphere in the X direction centered at the origin. This
| will leave behind half a sphere in the positive X direction.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> clipped_mesh = sphere.clip_closed_surface('-z')
| >>> clipped_mesh.plot(show_edges=True, line_width=3)
|
| Clip the sphere at the XY plane and leave behind half the
| sphere in the positive Z direction. Shift the clip upwards to
| leave a smaller mesh behind.
|
| >>> clipped_mesh = sphere.clip_closed_surface('z', origin=[0, 0, 0.3])
| >>> clipped_mesh.plot(show_edges=True, line_width=3)
|
| See :ref:`clip_closed_surface_example` for more examples using this filter.
|
| collision(self, other_mesh, contact_mode=0, box_tolerance=0.001, cell_tolerance=0.0, n_cells_per_node=2, generate_scalars: 'bool' = False, progress_bar: 'bool' = False)
| Perform collision determination between two polyhedral surfaces.
|
| If ``collision_mode`` is set to all contacts, the output will
| be lines of contact. If ``collision_mode`` is first contact or half
| contacts then the Contacts output will be vertices.
|
| .. warning::
| Currently only triangles are processed. Use
| :func:`PolyDataFilters.triangulate` to convert any strips
| or polygons to triangles. Otherwise, the mesh will be
| converted for you within this method.
|
| Parameters
| ----------
| other_mesh : pyvista.DataSet
| Other mesh to test collision with. If the other mesh is
| not a surface, its external surface will be extracted and
| triangulated.
|
| contact_mode : int, default: 0
| Contact mode. One of the following:
|
| * 0 - All contacts. Find all the contacting cell pairs
| with two points per collision
| * 1 - First contact. Quickly find the first contact point.
| * 2 - Half contacts. Find all the contacting cell pairs
| with one point per collision.
|
| box_tolerance : float, default: 0.001
| Oriented bounding box (OBB) tree tolerance in world coordinates.
|
| cell_tolerance : float, default: 0.0
| Cell tolerance (squared value).
|
| n_cells_per_node : int, default: 2
| Number of cells in each OBB.
|
| generate_scalars : bool, default: False
| Flag to visualize the contact cells. If ``True``, the
| contacting cells will be colored from red through blue,
| with collisions first determined colored red. This array
| is stored as ``"collision_rgba"``.
|
| .. note::
| This will remove any other cell arrays in the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing collisions in the ``field_data``
| attribute named ``"ContactCells"``. Array only exists
| when there are collisions.
|
| int
| Number of collisions.
|
| Notes
| -----
| Due to the nature of the :vtk:`vtkCollisionDetectionFilter`,
| repeated uses of this method will be slower that using the
| :vtk:`vtkCollisionDetectionFilter` directly. The first
| update of the filter creates two instances of :vtk:`vtkOBBTree`,
| which can be subsequently updated by modifying the transform or
| matrix of the input meshes.
|
| This method assumes no transform and is easier to use for
| single collision tests, but it is recommended to use a
| combination of ``pyvista`` and ``vtk`` for rapidly computing
| repeated collisions. See the `Collision Detection Example
| <https://kitware.github.io/vtk-examples/site/Python/Visualization/CollisionDetection/>`_
|
| Examples
| --------
| Compute the collision between a sphere and the back faces of a
| cube and output the cell indices of the first 10 collisions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere(radius=0.5)
| >>> mesh_b = pv.Cube(center=(0.5, 0.5, 0.5)).extract_cells([0, 2, 4])
| >>> collision, ncol = mesh_a.collision(mesh_b, cell_tolerance=1)
| >>> collision['ContactCells'][:10]
| pyvista_ndarray([464, 0, 0, 29, 29, 27, 27, 28, 28, 23])
|
| Plot the collisions by creating a collision mask with the
| ``"ContactCells"`` field data. Cells with a collision are
| colored red.
|
| >>> scalars = np.zeros(collision.n_cells, dtype=bool)
| >>> scalars[collision.field_data['ContactCells']] = True
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... collision,
| ... scalars=scalars,
| ... show_scalar_bar=False,
| ... cmap='bwr',
| ... )
| >>> _ = pl.add_mesh(
| ... mesh_b,
| ... color='lightblue',
| ... line_width=5,
| ... opacity=0.7,
| ... show_edges=True,
| ... )
| >>> pl.show()
|
| Alternatively, simply plot the collisions using the default
| ``'collision_rgba'`` array after enabling ``generate_scalars``.
|
| >>> collision, ncol = mesh_a.collision(
| ... mesh_b, cell_tolerance=1, generate_scalars=True
| ... )
| >>> collision.plot()
|
| See :ref:`collision_example` for more examples using this filter.
|
| compute_arc_length(self, progress_bar: 'bool' = False)
| Compute the arc length over the length of the probed line.
|
| It adds a new point-data array named ``"arc_length"`` with the
| computed arc length for each of the polylines in the
| input. For all other cell types, the arc length is set to 0.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| float
| Arc length of the length of the probed line.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> path = sphere.geodesic(0, 100)
| >>> length = path.compute_arc_length()['arc_length'][-1]
| >>> f'Length is {length:.3f}'
| 'Length is 0.812'
|
| This is identical to the geodesic_distance.
|
| >>> length = sphere.geodesic_distance(0, 100)
| >>> f'Length is {length:.3f}'
| 'Length is 0.812'
|
| You can also plot the arc_length.
|
| >>> arc = path.compute_arc_length()
| >>> arc.plot(scalars='arc_length')
|
| compute_normals(self, cell_normals: 'bool' = True, point_normals: 'bool' = True, split_vertices: 'bool' = False, flip_normals: 'bool' = False, consistent_normals: 'bool' = True, auto_orient_normals: 'bool' = False, non_manifold_traversal: 'bool' = True, feature_angle=30.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Compute point and/or cell normals for a mesh.
|
| The filter can reorder polygons to insure consistent
| orientation across polygon neighbors. Sharp edges can be split
| and points duplicated with separate normals to give crisp
| (rendered) surface definition. It is also possible to globally
| flip the normal orientation.
|
| The algorithm works by determining normals for each polygon
| and then averaging them at shared points. When sharp edges are
| present, the edges are split and new points generated to
| prevent blurry edges (due to Phong shading).
|
| An array named ``"Normals"`` is stored with the mesh.
|
| .. warning::
|
| - Normals can only be computed for polygons and triangle strips.
| Point clouds are not supported.
| - Triangle strips are broken up into triangle polygons.
| You may want to restrip the triangles.
| - Previous arrays named ``"Normals"`` will be overwritten.
|
| Parameters
| ----------
| cell_normals : bool, default: True
| Calculation of cell normals.
|
| point_normals : bool, default: True
| Calculation of point normals.
|
| split_vertices : bool, default: False
| Splitting of sharp edges. Indices to the original points are
| tracked in the ``"pyvistaOriginalPointIds"`` array.
|
| flip_normals : bool, default: False
| Set global flipping of normal orientation. Flipping
| modifies both the normal direction and the order of a
| cell's points.
|
| consistent_normals : bool, default: True
| Enforcement of consistent polygon ordering.
|
| auto_orient_normals : bool, default: False
| Turn on/off the automatic determination of correct normal
| orientation. NOTE: This assumes a completely closed
| surface (i.e. no boundary edges) and no non-manifold
| edges. If these constraints do not hold, all bets are
| off. This option adds some computational complexity, and
| is useful if you do not want to have to inspect the
| rendered image to determine whether to turn on the
| ``flip_normals`` flag. However, this flag can work with
| the ``flip_normals`` flag, and if both are set, all the
| normals in the output will point "inward".
|
| non_manifold_traversal : bool, default: True
| Turn on/off traversal across non-manifold edges. Changing
| this may prevent problems where the consistency of
| polygonal ordering is corrupted due to topological
| loops.
|
| feature_angle : float, default: 30.0
| The angle that defines a sharp edge. If the difference in
| angle across neighboring polygons is greater than this
| value, the shared edge is considered "sharp".
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Raises
| ------
| TypeError
| If the mesh contains only ``LINE`` or ``VERTEX`` cell types.
| Normals cannot be computed for these cells.
|
| Returns
| -------
| pyvista.PolyData
| Updated mesh with cell and point normals.
|
| See Also
| --------
| pyvista.PolyData.point_normals
| Returns the array of point normals.
| pyvista.PolyData.cell_normals
| Returns the array of cell normals.
| pyvista.PolyDataFilters.flip_normal_vectors
| Flip cell and point normals.
| pyvista.PolyDataFilters.flip_faces
| Flip the orientation of the faces.
|
| Examples
| --------
| Compute the point normals of the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere = sphere.compute_normals(cell_normals=False)
| >>> normals = sphere['Normals']
| >>> normals.shape
| (842, 3)
|
| Alternatively, create a new mesh when computing the normals
| and compute both cell and point normals.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_with_norm = sphere.compute_normals()
| >>> sphere_with_norm.point_data['Normals'].shape
| (842, 3)
| >>> sphere_with_norm.cell_data['Normals'].shape
| (1680, 3)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| contour_banded(self: 'PolyData', n_contours, rng=None, scalars=None, component=0, clip_tolerance=1e-06, generate_contour_edges: 'bool' = True, scalar_mode='value', clipping: 'bool' = True, progress_bar: 'bool' = False)
| Generate filled contours.
|
| Generates filled contours for :vtk:`vtkPolyData`. Filled contours are
| bands of cells that all have the same cell scalar value, and can
| therefore be colored the same. The method is also referred to as
| filled contour generation.
|
| This filter implements :vtk:`vtkBandedPolyDataContourFilter`.
|
| Parameters
| ----------
| n_contours : int
| Number of contours.
|
| rng : Sequence, optional
| Range of the scalars. Optional and defaults to the minimum and
| maximum of the active scalars of ``scalars``.
|
| scalars : str, optional
| The name of the scalar array to use for contouring. If ``None``,
| the active scalar array will be used.
|
| component : int, default: 0
| The component to use of an input scalars array with more than one
| component.
|
| clip_tolerance : float, default: 1e-6
| Set/Get the clip tolerance. Warning: setting this too large will
| certainly cause numerical issues. Change from the default value at
| your own risk. The actual internal clip tolerance is computed by
| multiplying ``clip_tolerance`` by the scalar range.
|
| generate_contour_edges : bool, default: True
| Controls whether contour edges are generated. Contour edges are
| the edges between bands. If enabled, they are generated from
| polygons/triangle strips and returned as a second output.
|
| scalar_mode : str, default: 'value'
| Control whether the cell scalars are output as an integer index or
| a scalar value. If ``'index'``, the index refers to the bands
| produced by the clipping range. If ``'value'``, then a scalar value
| which is a value between clip values is used.
|
| clipping : bool, default: True
| Indicate whether to clip outside ``rng`` and only return cells with
| values within ``rng``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData
| Surface containing the contour surface.
|
| edges : pyvista.PolyData
| Optional edges when ``generate_contour_edges`` is ``True``.
|
| Examples
| --------
| Plot the random hills dataset and with 8 contour lines. Note how we use 7
| colors here (``n_contours - 1``).
|
| >>> import pyvista as pv
| >>> from pyvista import examples
|
| >>> mesh = examples.load_random_hills()
| >>> n_contours = 8
| >>> _, edges = mesh.contour_banded(n_contours)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... edges,
| ... line_width=5,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(mesh, n_colors=n_contours - 1, cmap='Set3')
| >>> pl.show()
|
| Extract the surface from the uniform grid dataset and plot its contours
| alongside the output from the banded contour filter.
|
| >>> surf = examples.load_uniform().extract_surface(algorithm=None)
| >>> n_contours = 5
| >>> rng = [200, 500]
| >>> output, edges = surf.contour_banded(n_contours, rng=rng)
|
| >>> dargs = dict(n_colors=n_contours - 1, clim=rng)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... edges,
| ... line_width=5,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(surf, opacity=0.3, **dargs)
| >>> _ = pl.add_mesh(output, **dargs)
| >>> pl.show()
|
| curvature(self, curv_type='mean', progress_bar: 'bool' = False)
| Return the pointwise curvature of a mesh.
|
| See :ref:`connectivity_example` for more examples using this
| filter.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| Curvature type. One of the following:
|
| * ``"mean"``
| * ``"gaussian"``
| * ``"maximum"``
| * ``"minimum"``
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Array of curvature values.
|
| Examples
| --------
| Calculate the mean curvature of the hills example mesh and plot it.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> curv = hills.curvature()
| >>> hills.plot(scalars=curv)
|
| Show the curvature array.
|
| >>> curv # doctest:+SKIP
| array([0.20587616, 0.06747695, ..., 0.11781171, 0.15988467])
|
| decimate(self, target_reduction, volume_preservation: 'bool' = False, attribute_error: 'bool | None' = None, scalars: 'bool | None' = None, vectors: 'bool | None' = None, normals: 'bool | None' = None, tcoords: 'bool | None' = None, tensors: 'bool | None' = None, scalars_weight=0.1, vectors_weight=0.1, normals_weight=0.1, tcoords_weight=0.1, tensors_weight=0.1, inplace: 'bool' = False, progress_bar: 'bool' = False, boundary_constraints: 'bool' = False, boundary_weight: 'float' = 1.0, enable_all_attribute_error: 'bool' = False)
| Reduce the number of triangles in a triangular mesh using :vtk:`vtkQuadricDecimation`.
|
| .. versionchanged:: 0.45
| ``scalars``, ``vectors``, ``normals``, ``tcoords`` and ``tensors`` are now disabled by
| default. They can be enabled all together using ``enable_all_attribute_error``.
|
|
| Parameters
| ----------
| target_reduction : float
| Fraction of the original mesh to remove.
| If ``target_reduction`` is set to 0.9, this filter will try
| to reduce the data set to 10% of its original size and will
| remove 90% of the input triangles.
|
| volume_preservation : bool, default: False
| Decide whether to activate volume preservation which greatly
| reduces errors in triangle normal direction. If ``False``,
| volume preservation is disabled and if ``attribute_error``
| is active, these errors can be large.
|
| attribute_error : bool, default: False
| Decide whether to include data attributes in the error metric. If
| ``False``, then only geometric error is used to control the
| decimation. If ``True``, the following flags are used to specify
| which attributes are to be included in the error calculation.
|
| .. deprecated:: 0.45.0
|
| scalars : bool, default: False
| This flags control specifically if the **scalar** attributes
| are to be included in the error calculation.
|
| vectors : bool, default: False
| See ``scalars`` parameter.
|
| normals : bool, default: False
| See ``scalars`` parameter.
| .. versionchanged:: 0.45.0
|
| tcoords : bool, default: False
| See ``scalars`` parameter.
|
| tensors : bool, default: False
| See ``scalars`` parameter.
|
| scalars_weight : float, default: 0.1
| The scaling weight contribution of the scalar attribute.
| These values are used to weight the contribution of the
| attributes towards the error metric.
|
| vectors_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| normals_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| tcoords_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| tensors_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| boundary_constraints: bool, default: False
| Use the legacy weighting by boundary_edge_length instead of by
| boundary_edge_length^2 for backwards compatibility.
| It requires vtk>=9.3.0.
|
| .. versionadded:: 0.45.0
|
| boundary_weight: float, default: 1.0
| A floating point factor to weigh the boundary quadric constraints
| by: higher factors further constrain the boundary.
| It requires vtk>=9.3.0.
|
| .. versionadded:: 0.45.0
|
| enable_all_attribute_error: bool, default: False
| This flag control the default value of all attribute metrics to
| eventually include them in the error calculation
|
| .. versionadded:: 0.45.0
|
| Returns
| -------
| pyvista.PolyData
| Decimated mesh.
|
| See Also
| --------
| decimate_pro
| Another option for triangular meshes.
| decimate_polyline
| For use with polylines.
|
| Notes
| -----
| If you encounter a segmentation fault or other error, consider using
| :func:`pyvista.PolyDataFilters.clean` to remove any invalid cells
| before using this filter.
|
| Examples
| --------
| Decimate a sphere. First plot the sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=60, theta_resolution=60)
| >>> sphere.plot(show_edges=True, line_width=2)
|
| Now decimate it by 75% and plot it.
|
| >>> decimated = sphere.decimate(0.75)
| >>> decimated.plot(show_edges=True, line_width=2)
|
| Decimate taking scalars attributes into account:
|
| >>> decimated = sphere.decimate(0.5, scalars=True)
|
| Decimate taking all attributes **except** normals into account:
|
| >>> decimated = sphere.decimate(
| ... 0.5, enable_all_attribute_error=True, normals=False
| ... )
|
| See :ref:`decimate_example` for more examples using this filter.
|
| decimate_polyline(self, reduction: 'float', *, maximum_error: 'float' = 10.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Reduce the number of lines in a polyline mesh.
|
| This filter uses :vtk:`vtkDecimatePolylineFilter`.
|
| .. versionadded:: 0.45.0
|
| Parameters
| ----------
| reduction : float
| Reduction factor. A value of 0.9 will leave 10% of the
| original number of vertices.
|
| maximum_error : float, default: 10.
| Fraction of the maximum length of the input data bounding box
| to limit reduction. This might prevent the full reduction from
| being achieved. Default of ``10.`` should not limit reduction.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated mesh.
|
| Warnings
| --------
| From :vtk:`vtkDecimatePolylineFilter` documentation: this algorithm is a very
| simple implementation that overlooks some potential complexities.
| For example, if a vertex is multiply connected, meaning that it is
| used by multiple distinct polylines, then the extra topological
| constraints are ignored. This can produce less than optimal results.
|
| See Also
| --------
| decimate
| For use with triangular meshes.
| decimate_pro
| Another option for triangular meshes.
|
| Examples
| --------
| Generate a circle, builtin function returns a Polygon cell.
|
| >>> import pyvista as pv
| >>> circle = pv.Circle(resolution=30)
|
| Convert to a Polyline. A polyline requires duplicating reference
| to initial point to close the circle.
|
| >>> circle_polyline = pv.PolyData(
| ... circle.points, lines=[31] + list(range(30)) + [0]
| ... )
| >>> circle_polyline.n_points
| 30
|
| Decimate ~50% of points.
|
| >>> decimate_some = circle_polyline.decimate_polyline(0.5)
| >>> decimate_some.n_points
| 14
|
| Decimate more points.
|
| >>> decimate_more = circle_polyline.decimate_polyline(0.75)
| >>> decimate_more.n_points
| 6
|
| Compare decimated polylines.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(circle_polyline, label='Circle', color='red', line_width=5)
| >>> _ = pl.add_mesh(
| ... decimate_some,
| ... label='Decimated some',
| ... color='blue',
| ... line_width=5,
| ... )
| >>> _ = pl.add_mesh(
| ... decimate_more,
| ... label='Decimated more',
| ... color='black',
| ... line_width=5,
| ... )
| >>> pl.view_xy()
| >>> _ = pl.add_legend(face='line', size=(0.25, 0.25))
| >>> pl.show()
|
| See :ref:`decimate_example` for more examples using this filter.
|
| decimate_pro(self, reduction, feature_angle=45.0, split_angle=75.0, splitting: 'bool' = True, pre_split_mesh: 'bool' = False, preserve_topology: 'bool' = False, boundary_vertex_deletion: 'bool' = True, max_degree=None, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Reduce the number of triangles in a triangular mesh.
|
| It forms a good approximation to the original geometry. Based
| on the algorithm originally described in "Decimation of
| Triangle Meshes", Proc Siggraph 92
| (https://doi.org/10.1145/133994.134010).
|
| Parameters
| ----------
| reduction : float
| Reduction factor. A value of 0.9 will leave 10% of the
| original number of vertices.
|
| feature_angle : float, default: 45.0
| Angle used to define what an edge is (i.e., if the surface
| normal between two adjacent triangles is >= ``feature_angle``,
| an edge exists).
|
| split_angle : float, default: 75.0
| Angle used to control the splitting of the mesh. A split
| line exists when the surface normals between two edge
| connected triangles are >= ``split_angle``.
|
| splitting : bool, default: True
| Controls the splitting of the mesh at corners, along
| edges, at non-manifold points, or anywhere else a split is
| required. Turning splitting off will better preserve the
| original topology of the mesh, but may not necessarily
| give the exact requested decimation.
|
| pre_split_mesh : bool, default: False
| Separates the mesh into semi-planar patches, which are
| disconnected from each other. This can give superior
| results in some cases. If ``pre_split_mesh`` is set to
| ``True``, the mesh is split with the specified
| ``split_angle``. Otherwise mesh splitting is deferred as
| long as possible.
|
| preserve_topology : bool, default: False
| Controls topology preservation. If on, mesh splitting and
| hole elimination will not occur. This may limit the
| maximum reduction that may be achieved.
|
| boundary_vertex_deletion : bool, default: True
| Allow deletion of vertices on the boundary of the mesh.
| Turning this off may limit the maximum reduction that may
| be achieved.
|
| max_degree : float, optional
| The maximum vertex degree. If the number of triangles
| connected to a vertex exceeds ``max_degree``, then the
| vertex will be split. The complexity of the triangulation
| algorithm is proportional to ``max_degree**2``. Setting ``max_degree``
| small can improve the performance of the algorithm.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated mesh.
|
| See Also
| --------
| decimate
| Another option for triangular meshes.
| decimate_polyline
| For use with polylines.
|
| Examples
| --------
| Decimate a sphere. First plot the sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=60, theta_resolution=60)
| >>> sphere.plot(show_edges=True, line_width=2)
|
| Now decimate it and plot it.
|
| >>> decimated = sphere.decimate_pro(0.75)
| >>> decimated.plot(show_edges=True, line_width=2)
|
| See :ref:`decimate_example` for more examples using this filter.
|
| delaunay_2d(self, tol=1e-05, alpha=0.0, offset=1.0, bound: 'bool' = False, inplace: 'bool' = False, edge_source=None, progress_bar: 'bool' = False)
| Apply a 2D Delaunay filter along the best fitting plane.
|
| This filter can be used to generate a 2d surface from a set of
| points on a plane. If you want to create a surface from a
| point cloud, see :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| tol : float, default: 1e-05
| Specify a tolerance to control discarding of closely
| spaced points. This tolerance is specified as a fraction
| of the diagonal length of the bounding box of the points.
|
| alpha : float, default: 0.0
| Specify alpha (or distance) value to control output of
| this filter. For a non-zero alpha value, only edges or
| triangles contained within a sphere centered at mesh
| vertices will be output. Otherwise, only triangles will be
| output.
|
| offset : float, default: 1.0
| Specify a multiplier to control the size of the initial,
| bounding Delaunay triangulation.
|
| bound : bool, default: False
| Boolean controls whether bounding triangulation points
| and associated triangles are included in the
| output. These are introduced as an initial triangulation
| to begin the triangulation process. This feature is nice
| for debugging output.
|
| inplace : bool, default: False
| If ``True``, overwrite this mesh with the triangulated
| mesh.
|
| edge_source : pyvista.PolyData, optional
| Specify the source object used to specify constrained
| edges and loops. If set, and lines/polygons are defined, a
| constrained triangulation is created. The lines/polygons
| are assumed to reference points in the input point set
| (i.e. point ids are identical in the input and
| source).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh from the 2D delaunay filter.
|
| Examples
| --------
| First, generate 30 points on circle and plot them.
|
| >>> import pyvista as pv
| >>> points = pv.Polygon(n_sides=30).points
| >>> circle = pv.PolyData(points)
| >>> circle.plot(show_edges=True, point_size=15)
|
| Use :func:`delaunay_2d` to fill the interior of the circle.
|
| >>> filled_circle = circle.delaunay_2d()
| >>> filled_circle.plot(show_edges=True, line_width=5)
|
| Use the ``edge_source`` parameter to create a constrained delaunay
| triangulation and plot it.
|
| >>> squar = pv.Polygon(n_sides=4, radius=8, fill=False)
| >>> squar = squar.rotate_z(45, inplace=False)
| >>> circ0 = pv.Polygon(center=(2, 3, 0), n_sides=30, radius=1)
| >>> circ1 = pv.Polygon(center=(-2, -3, 0), n_sides=30, radius=1)
| >>> comb = circ0.append_polydata(circ1, squar)
| >>> tess = comb.delaunay_2d(edge_source=comb)
| >>> tess.plot(cpos='xy', show_edges=True)
|
| See :ref:`create_tri_surface_example` for more examples using this filter.
|
| edge_mask(self, angle, progress_bar: 'bool' = False)
| Return a mask of the points of a surface mesh with a surface angle greater than angle.
|
| Parameters
| ----------
| angle : float
| Angle to consider an edge.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Mask of points with an angle greater than ``angle``.
|
| Examples
| --------
| Plot the mask of points that exceed 45 degrees.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube().triangulate().subdivide(4)
| >>> mask = mesh.edge_mask(45)
| >>> mesh.plot(scalars=mask)
|
| Show the array of masked points.
|
| >>> mask # doctest:+SKIP
| array([ True, True, True, ..., False, False, False])
|
| extrude(self, vector, capping=None, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Sweep polygonal data creating a "skirt" from free edges.
|
| This will create a line from vertices.
|
| This takes polygonal data as input and generates polygonal
| data on output. The input dataset is swept according to some
| extrusion function and creates new polygonal primitives. These
| primitives form a "skirt" or swept surface. For example,
| sweeping a line results in a quadrilateral, and sweeping a
| triangle creates a "wedge".
|
| The skirt is generated by locating certain topological
| features. Free edges (edges of polygons or triangle strips
| only used by one polygon or triangle strips) generate
| surfaces. This is true also of lines or polylines. Vertices
| generate lines.
|
| .. versionchanged:: 0.32.0
| The ``capping`` keyword was added with a default of ``False``.
| The previously used VTK default corresponds to ``capping=True``.
| In a future version the default will be changed to ``True`` to
| match the behavior of the underlying VTK filter.
|
| Parameters
| ----------
| vector : numpy.ndarray or sequence
| Direction and length to extrude the mesh in.
|
| capping : bool, optional
| Control if the sweep of a 2D object is capped. The default is
| ``False``, which differs from VTK's default.
|
| .. warning::
| The ``capping`` keyword was added in version 0.32.0 with a
| default value of ``False``. In a future version this default
| will be changed to ``True`` to match the behavior of the
| underlying VTK filter. It is recommended to explicitly pass
| a value for this keyword argument to prevent future changes
| in behavior and warnings.
|
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extruded mesh.
|
| Examples
| --------
| Extrude a half circle arc.
|
| >>> import pyvista as pv
| >>> arc = pv.CircularArc(pointa=[-1, 0, 0], pointb=[1, 0, 0], center=[0, 0, 0])
| >>> mesh = arc.extrude([0, 0, 1], capping=False)
| >>> mesh.plot(color='lightblue')
|
| Extrude and cap an 8 sided polygon.
|
| >>> poly = pv.Polygon(n_sides=8)
| >>> mesh = poly.extrude((0, 0, 1.5), capping=True)
| >>> mesh.plot(line_width=5, show_edges=True)
|
| extrude_rotate(self, resolution=30, inplace: 'bool' = False, translation=0.0, dradius=0.0, angle=360.0, capping=None, rotation_axis=(0, 0, 1), progress_bar: 'bool' = False)
| Sweep polygonal data creating "skirt" from free edges/lines, and lines from vertices.
|
| This takes polygonal data as input and generates polygonal
| data on output. The input dataset is swept around the axis
| to create new polygonal primitives. These primitives form a
| "skirt" or swept surface. For example, sweeping a line results
| in a cylindrical shell, and sweeping a circle creates a torus.
|
| There are a number of control parameters for this filter. You
| can control whether the sweep of a 2D object (i.e., polygon or
| triangle strip) is capped with the generating geometry via the
| ``capping`` parameter. Also, you can control the angle of
| rotation, and whether translation along the axis is
| performed along with the rotation. (Translation is useful for
| creating "springs".) You also can adjust the radius of the
| generating geometry with the ``dradius`` parameter.
|
| The skirt is generated by locating certain topological
| features. Free edges (edges of polygons or triangle strips
| only used by one polygon or triangle strips) generate
| surfaces. This is true also of lines or polylines. Vertices
| generate lines.
|
| This filter can be used to model axisymmetric objects like
| cylinders, bottles, and wine glasses; or translational
| rotational symmetric objects like springs or corkscrews.
|
| .. versionchanged:: 0.32.0
| The ``capping`` keyword was added with a default of ``False``.
| The previously used VTK default corresponds to ``capping=True``.
| In a future version the default will be changed to ``True`` to
| match the behavior of the underlying VTK filter.
|
| Parameters
| ----------
| resolution : int, optional
| Number of pieces to divide line into.
|
| inplace : bool, default: False
| Overwrites the original mesh inplace.
|
| translation : float, optional
| Total amount of translation along the axis.
|
| dradius : float, optional
| Change in radius during sweep process.
|
| angle : float, optional
| The angle of rotation in degrees.
|
| capping : bool, optional
| Control if the sweep of a 2D object is capped. The default is
| ``False``, which differs from VTK's default.
|
| .. warning::
| The ``capping`` keyword was added in version 0.32.0 with a
| default value of ``False``. In a future version this default
| will be changed to ``True`` to match the behavior of the
| underlying VTK filter. It is recommended to explicitly pass
| a value for this keyword argument to prevent future changes
| in behavior and warnings.
|
| rotation_axis : numpy.ndarray or sequence, optional
| The direction vector of the axis around which the rotation is done.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Rotationally extruded mesh.
|
| See Also
| --------
| :ref:`extrude_rotate_example`
|
| Examples
| --------
| Create a "spring" using the rotational extrusion filter.
|
| >>> import pyvista as pv
| >>> profile = pv.Polygon(
| ... center=[1.25, 0.0, 0.0],
| ... radius=0.2,
| ... normal=(0, 1, 0),
| ... n_sides=30,
| ... )
| >>> extruded = profile.extrude_rotate(
| ... resolution=360,
| ... translation=4.0,
| ... dradius=0.5,
| ... angle=1500.0,
| ... capping=True,
| ... )
| >>> extruded.plot(smooth_shading=True)
|
| Create a "wine glass" using the rotational extrusion filter.
|
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [-0.18, 0, 0],
| ... [-0.18, 0, 0.01],
| ... [-0.18, 0, 0.02],
| ... [-0.01, 0, 0.03],
| ... [-0.01, 0, 0.04],
| ... [-0.02, 0, 0.5],
| ... [-0.05, 0, 0.75],
| ... [-0.1, 0, 0.8],
| ... [-0.2, 0, 1.0],
| ... ]
| ... )
| >>> spline = pv.Spline(points, 30)
| >>> extruded = spline.extrude_rotate(resolution=20, capping=False)
| >>> extruded.plot(color='lightblue')
|
| extrude_trim(self, direction, trim_surface, extrusion='boundary_edges', capping='intersection', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extrude polygonal data trimmed by a surface.
|
| The input dataset is swept along a specified direction forming a
| "skirt" from the boundary edges 2D primitives (i.e., edges used
| by only one polygon); and/or from vertices and lines. The extent
| of the sweeping is defined where the sweep intersects a
| user-specified surface.
|
| Parameters
| ----------
| direction : numpy.ndarray or sequence
| Direction vector to extrude.
|
| trim_surface : pyvista.PolyData
| Surface which trims the surface.
|
| extrusion : str, default: "boundary_edges"
| Control the strategy of extrusion. One of the following:
|
| * ``"boundary_edges"``
| * ``"all_edges"``
|
| The default only generates faces on the boundary of the original
| input surface. When using ``"all_edges"``, faces are created along
| interior points as well.
|
| capping : str, default: "intersection"
| Control the strategy of capping. One of the following:
|
| * ``"intersection"``
| * ``"minimum_distance"``
| * ``"maximum_distance"``
| * ``"average_distance"``
|
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extruded mesh trimmed by a surface.
|
| See Also
| --------
| :ref:`extrude_trim_example`
|
| Examples
| --------
| Extrude a disc.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> plane = pv.Plane(i_size=2, j_size=2, direction=[0, 0.8, 1])
| >>> disc = pv.Disc(center=(0, 0, -1), c_res=50)
| >>> direction = [0, 0, 1]
| >>> extruded_disc = disc.extrude_trim(direction, plane)
| >>> extruded_disc.plot(smooth_shading=True, split_sharp_edges=True)
|
| fill_holes(self, hole_size, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Fill holes in a :class:`pyvista.PolyData` or :vtk:`vtkPolyData` object.
|
| Holes are identified by locating boundary edges, linking them
| together into loops, and then triangulating the resulting
| loops. Note that you can specify an approximate limit to the
| size of the hole that can be filled.
|
| .. warning::
| This method is known to segfault. Use at your own risk.
|
| Parameters
| ----------
| hole_size : float
| Specifies the maximum hole size to fill. This is
| represented as a radius to the bounding circumsphere
| containing the hole. Note that this is an approximate
| area; the actual area cannot be computed without first
| triangulating the hole.
|
| inplace : bool, default: False
| Return new mesh or overwrite input.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh with holes filled if ``inplace=False``.
|
| Examples
| --------
| Create a partial sphere with a hole and then fill it.
|
| >>> import pyvista as pv
| >>> sphere_with_hole = pv.Sphere(end_theta=330)
| >>> sphere = sphere_with_hole.fill_holes(1000) # doctest:+SKIP
| >>> edges = sphere.extract_feature_edges(
| ... feature_edges=False, manifold_edges=False
| ... ) # doctest:+SKIP
| >>> assert edges.n_cells == 0 # doctest:+SKIP
|
| See :ref:`fill_holes_example` for more examples using this filter.
|
| flip_faces(self: 'PolyData', *, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Flip the orientation of the faces.
|
| The flip is performed by reversing the order of indices in the cell
| connectivity list. In other libraries, this operation is sometimes
| referred to as "flip orientation", "reverse cells", "reverse face
| orientations", or similar.
|
| .. note::
|
| Polygon cells have an implicitly-defined orientation, and reversing
| the ordering affects how normals are computed by filters like
| :meth:`~pyvista.PolyDataFilters.compute_normals`.
|
| .. note::
| This filter does not modify any existing normals which may be present
| in the dataset. Use :meth:`~pyvista.PolyDataFilters.flip_normal_vectors`
| to flip the normal vectors.
|
| .. warning::
|
| This filter does not produce the correct output for
| :attr:`~pyvista.CellType.TRIANGLE_STRIP` cells,
| see https://gitlab.kitware.com/vtk/vtk/-/issues/18634.
| Use :meth:`~pyvista.PolyDataFilters.triangulate` to triangulate the mesh
| first.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh with flipped faces.
|
| See Also
| --------
| pyvista.PolyDataFilters.flip_normal_vectors
| Flip the direction of the point and cell normals.
| pyvista.PolyDataFilters.compute_normals
| Compute new normals. Includes the option to flip the normals.
| pyvista.PolyData.point_normals
| Returns the array of point normals.
| pyvista.PolyData.cell_normals
| Returns the array of cell normals.
|
| Examples
| --------
| Flip the faces of a sphere. Show the point ids of the first cell
| before and after the flip.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.regular_faces[0]
| array([ 2, 30, 0])
|
| >>> sphere_flipped = sphere.flip_faces()
| >>> sphere_flipped.regular_faces[0]
| array([ 0, 30, 2])
|
| Note that the sphere also has pre-computed normals which have not been
| affected by this filter.
|
| >>> sphere.point_data['Normals'][0]
| pyvista_ndarray([0., 0., 1.], dtype=float32)
|
| >>> sphere_flipped.point_data['Normals'][0]
| pyvista_ndarray([0., 0., 1.], dtype=float32)
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| flip_normal_vectors(self: 'PolyData', *, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Flip the direction of the mesh's point and cell normal vectors.
|
| This filter effectively multiplies the point and cell normals by ``-1``.
| It has no effect if no active normals are currently set.
|
| .. note::
|
| Polygon cells have an implicitly-defined orientation which may differ
| from the orientation of the normal vectors. To ensure that the normals
| are consistent with this implicit definition, consider also using
| :meth:`~pyvista.PolyDataFilters.flip_faces` or re-computing normals with
| :meth:`~pyvista.PolyDataFilters.compute_normals` and enabling the
| `flip_normals` option.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh with point and cell normal directions flipped.
|
| See Also
| --------
| pyvista.PolyDataFilters.flip_faces
| Flip the orientation of the faces.
| pyvista.PolyDataFilters.compute_normals
| Compute new normals. Includes the option to flip the normals.
| pyvista.PolyData.point_normals
| Returns the array of point normals.
| pyvista.PolyData.cell_normals
| Returns the array of cell normals.
|
| Examples
| --------
| Flip the normal vectors of a sphere. Show one of the normal vectors
| before and after the flip.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.point_data['Normals'][0]
| pyvista_ndarray([0., 0., 1.], dtype=float32)
|
| >>> sphere_flipped = sphere.flip_normal_vectors()
| >>> sphere_flipped.point_data['Normals'][0]
| pyvista_ndarray([-0., -0., -1.], dtype=float32)
|
| Note that the sphere's cell ordering has not been affected by this filter.
|
| >>> sphere.regular_faces[0]
| array([ 2, 30, 0])
|
| >>> sphere_flipped.regular_faces[0]
| array([ 2, 30, 0])
|
| flip_normals(self)
| Flip normals of a triangular mesh by reversing the point ordering.
|
| .. deprecated:: 0.45
|
| This filter is deprecated. Use ``flip_faces(inplace=True)`` instead.
|
| Examples
| --------
| Flip the normals of a sphere and plot the normals before and
| after the flip.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.plot_normals(mag=0.1)
| >>> sphere.flip_normals() # doctest:+SKIP
| >>> sphere.plot_normals(mag=0.1, opacity=0.5)
|
| geodesic(self, start_vertex, end_vertex, inplace: 'bool' = False, keep_order: 'bool' = True, use_scalar_weights: 'bool' = False, progress_bar: 'bool' = False)
| Calculate the geodesic path between two vertices using Dijkstra's algorithm.
|
| This will add an array titled ``'vtkOriginalPointIds'`` of the input
| mesh's point ids to the output mesh. The default behavior of the
| underlying :vtk:`vtkDijkstraGraphGeodesicPath` filter is that the
| geodesic path is reversed in the resulting mesh. This is overridden
| in PyVista by default.
|
| Parameters
| ----------
| start_vertex : int
| Vertex index indicating the start point of the geodesic segment.
|
| end_vertex : int
| Vertex index indicating the end point of the geodesic segment.
|
| inplace : bool, default: False
| Whether the input mesh should be replaced with the path. The
| geodesic path is always returned.
|
| keep_order : bool, default: True
| If ``True``, the points of the returned path are guaranteed
| to start with the start vertex (as opposed to the end vertex).
|
| .. versionadded:: 0.32.0
|
| use_scalar_weights : bool, default: False
| If ``True``, use scalar values in the edge weight.
| This only works for point data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| ``PolyData`` object consisting of the line segment between the
| two given vertices. If ``inplace`` is ``True`` this is the
| same object as the input mesh.
|
| Examples
| --------
| Plot the path between two points on the random hills mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> path = hills.geodesic(560, 5820)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills)
| >>> _ = pl.add_mesh(path, line_width=5, color='k')
| >>> pl.show()
|
| See :ref:`geodesic_example` for more examples using this filter.
|
| geodesic_distance(self, start_vertex, end_vertex, use_scalar_weights: 'bool' = False, progress_bar: 'bool' = False)
| Calculate the geodesic distance between two vertices using Dijkstra's algorithm.
|
| Parameters
| ----------
| start_vertex : int
| Vertex index indicating the start point of the geodesic segment.
|
| end_vertex : int
| Vertex index indicating the end point of the geodesic segment.
|
| use_scalar_weights : bool, default: False
| If ``True``, use scalar values in the edge weight.
| This only works for point data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| float
| Length of the geodesic segment.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> length = sphere.geodesic_distance(0, 100)
| >>> f'Length is {length:.3f}'
| 'Length is 0.812'
|
| See :ref:`geodesic_example` for more examples using this filter.
|
| intersection(self, mesh, split_first: 'bool' = True, split_second: 'bool' = True, progress_bar: 'bool' = False)
| Compute the intersection between two meshes.
|
| .. note::
| This method returns the surface intersection from two meshes
| (which often resolves as a line), whereas the
| :func:`PolyDataFilters.boolean_intersection` filter returns
| the "volume" intersection between two closed (manifold)
| meshes.
|
| Parameters
| ----------
| mesh : pyvista.PolyData
| The mesh to intersect with.
|
| split_first : bool, default: True
| If ``True``, return the first input mesh split by the
| intersection with the second input mesh.
|
| split_second : bool, default: True
| If ``True``, return the second input mesh split by the
| intersection with the first input mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The intersection line.
|
| pyvista.PolyData
| The first mesh split along the intersection. Returns the
| original first mesh if ``split_first=False``.
|
| pyvista.PolyData
| The second mesh split along the intersection. Returns the
| original second mesh if ``split_second=False``.
|
| Examples
| --------
| Intersect two spheres, returning the intersection and both spheres
| which have new points/cells along the intersection line.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> s1 = pv.Sphere(phi_resolution=15, theta_resolution=15)
| >>> s2 = s1.copy()
| >>> s2.points += np.array([0.25, 0, 0])
| >>> intersection, s1_split, s2_split = s1.intersection(s2)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(s1, style='wireframe')
| >>> _ = pl.add_mesh(s2, style='wireframe')
| >>> _ = pl.add_mesh(intersection, color='r', line_width=10)
| >>> pl.show()
|
| The mesh splitting takes additional time and can be turned
| off for either mesh individually.
|
| >>> intersection, _, s2_split = s1.intersection(
| ... s2, split_first=False, split_second=True
| ... )
|
| merge(self: 'PolyData', dataset, merge_points: 'bool' = True, tolerance=0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Merge this mesh with one or more datasets.
|
| .. note::
| The behavior of this filter varies from the
| :func:`PolyDataFilters.boolean_union` filter. This filter
| does not attempt to create a manifold mesh and will include
| internal surfaces when two meshes overlap.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the other mesh is also a
| :class:`pyvista.PolyData`, in-place merging via ``+=`` is
| similarly possible.
|
| .. versionchanged:: 0.39.0
| Before version ``0.39.0``, if all input datasets were of type
| :class:`pyvista.PolyData`, the VTK :vtk:`vtkAppendPolyData` and
| :vtk:`vtkCleanPolyData` filters were used to perform merging.
| Otherwise, :func:`DataSetFilters.merge`, which uses the VTK
| :vtk:`vtkAppendFilter` filter, was called.
| To enhance performance and coherence with merging operations
| available for other datasets in pyvista, the merging operation
| has been delegated in ``0.39.0`` to :func:`DataSetFilters.merge`
| only, irrespectively of input datasets types.
| This induced that points ordering can be altered compared to
| previous pyvista versions when merging only PolyData together.
| To obtain similar results as before ``0.39.0`` for multiple PolyData, combine
| :func:`PolyDataFilters.append_polydata` and :func:`PolyDataFilters.clean`.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| .. seealso::
| :func:`PolyDataFilters.append_polydata`
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| PyVista dataset to merge this mesh with.
|
| merge_points : bool, optional
| Merge equivalent points when ``True``.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when ``True`` if the input type is a
| :class:`pyvista.PolyData`. For other input meshes the
| result is a :class:`pyvista.UnstructuredGrid` which makes
| in-place operation impossible.
|
| main_has_priority : bool, optional
| When this parameter is ``True`` and ``merge_points=True``,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| :class:`pyvista.PolyData` if ``dataset`` is a
| :class:`pyvista.PolyData`, otherwise a
| :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> merged = sphere_a.merge(sphere_b)
| >>> merged.plot(style='wireframe', color='lightblue')
|
| multi_ray_trace(self: 'PolyData', origins, directions, first_point: 'bool' = False, retry: 'bool' = False)
| Perform multiple ray trace calculations.
|
| This requires a mesh with only triangular faces, an array of
| origin points and an equal sized array of direction vectors to
| trace along.
|
| The embree library used for vectorization of the ray traces is
| known to occasionally return no intersections where the VTK
| implementation would return an intersection. If the result
| appears to be missing some intersection points, set
| ``retry=True`` to run a second pass over rays that returned no
| intersections, using :func:`PolyDataFilters.ray_trace`.
|
| Parameters
| ----------
| origins : array_like[float]
| Starting point for each trace.
|
| directions : array_like[float]
| Direction vector for each trace.
|
| first_point : bool, default: False
| Returns intersection of first point only.
|
| retry : bool, default: False
| Will retry rays that return no intersections using
| :func:`PolyDataFilters.ray_trace`.
|
| Returns
| -------
| intersection_points : numpy.ndarray
| Location of the intersection points. Empty array if no
| intersections.
|
| intersection_rays : numpy.ndarray
| Indices of the ray for each intersection point. Empty array if no
| intersections.
|
| intersection_cells : numpy.ndarray
| Indices of the intersection cells. Empty array if no
| intersections.
|
| Examples
| --------
| Compute the intersection between rays from the origin in
| directions ``[1, 0, 0]``, ``[0, 1, 0]`` and ``[0, 0, 1]``, and
| a sphere with radius 0.5 centered at the origin
|
| >>> import pyvista as pv # doctest:+SKIP
| >>> sphere = pv.Sphere() # doctest:+SKIP
| >>> points, rays, cells = sphere.multi_ray_trace(
| ... [[0, 0, 0]] * 3,
| ... [[1, 0, 0], [0, 1, 0], [0, 0, 1]],
| ... first_point=True,
| ... ) # doctest:+SKIP
| >>> string = ', '.join(
| ... [
| ... f'({point[0]:.3f}, {point[1]:.3f}, {point[2]:.3f})'
| ... for point in points
| ... ]
| ... ) # doctest:+SKIP
| >>> f'Rays intersected at {string}' # doctest:+SKIP
| 'Rays intersected at (0.499, 0.000, 0.000), (0.000, 0.497, 0.000), (0.000, 0.000, 0.500)'
|
| plot_boundaries(self: 'PolyData', edge_color='red', line_width=None, progress_bar: 'bool' = False, **kwargs)
| Plot boundaries of a mesh.
|
| Parameters
| ----------
| edge_color : ColorLike, default: "red"
| The color of the edges when they are added to the plotter.
|
| line_width : int, optional
| Width of the boundary lines.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| All additional keyword arguments will be passed to
| :func:`pyvista.Plotter.add_mesh`.
|
| Returns
| -------
| pyvista.CameraPosition
| List of camera position, focal point, and view up.
| Returned when ``return_cpos`` is ``True``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot_boundaries(line_width=10)
|
| plot_curvature(self, curv_type='mean', **kwargs)
| Plot the curvature.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| One of the following strings indicating curvature type:
|
| * ``'mean'``
| * ``'gaussian'``
| * ``'maximum'``
| * ``'minimum'``
|
| **kwargs : dict, optional
| See :func:`pyvista.plot`.
|
| Returns
| -------
| pyvista.CameraPosition
| List of camera position, focal point, and view up.
| Returned when ``return_cpos`` is ``True``.
|
| Examples
| --------
| Plot the Gaussian curvature of an example mesh. Override the
| default scalar bar range as the mesh edges report high
| curvature.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot_curvature(
| ... curv_type='gaussian', smooth_shading=True, clim=[0, 1]
| ... )
|
| plot_normals(self: 'PolyData', show_mesh: 'bool' = True, mag=1.0, flip: 'bool' = False, use_every=1, faces: 'bool' = False, color=None, **kwargs)
| Plot the point normals of a mesh.
|
| Parameters
| ----------
| show_mesh : bool, default: True
| Plot the mesh itself.
|
| mag : float, default: 1.0
| Size magnitude of the normal arrows.
|
| flip : bool, default: False
| Flip the normal direction when ``True``.
|
| use_every : int, default: 1
| Display every nth normal. By default every normal is
| displayed. Display every 10th normal by setting this
| parameter to 10.
|
| faces : bool, default: False
| Plot face normals instead of the default point normals.
|
| color : ColorLike, optional
| Color of the arrows. Defaults to
| :attr:`pyvista.plotting.themes.Theme.edge_color`.
|
| **kwargs : dict, optional
| All additional keyword arguments will be passed to
| :func:`pyvista.Plotter.add_mesh`.
|
| Returns
| -------
| pyvista.CameraPosition
| List of camera position, focal point, and view up.
| Returned when ``return_cpos`` is ``True``.
|
| Examples
| --------
| Plot the point normals of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=10, theta_resolution=10)
| >>> sphere.plot_normals(mag=0.1, show_edges=True)
|
| Plot the face normals of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=10, theta_resolution=10)
| >>> sphere.plot_normals(mag=0.1, faces=True, show_edges=True)
|
| project_points_to_plane(self: 'PolyData', origin: 'VectorLike[float] | None' = None, normal: 'VectorLike[float] | _NormalsLiteral | None' = None, inplace: 'bool' = False, plane: 'PolyData | None' = None)
| Project points of this mesh to a plane.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| Parameters
| ----------
| origin : VectorLike[float], optional
| Plane origin. Defaults to the approximate center of the
| input mesh minus half the length of the input mesh in the
| direction of the normal.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector for the plane's normal. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'z'`` direction is used by default.
|
| inplace : bool, default: False
| Whether to overwrite the original mesh with the projected
| points.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to project to. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| The points of this mesh projected onto a plane.
|
| See Also
| --------
| :ref:`project_plane_example`
| :ref:`project_points_tessellate_example`
|
| Examples
| --------
| Flatten a sphere to the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> projected = sphere.project_points_to_plane()
|
| Plot the projected sphere along with the original.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(projected, show_edges=True, line_width=3)
| >>> _ = pl.add_mesh(sphere)
| >>> _ = pl.show_grid()
| >>> cpos = pv.CameraPosition(
| ... position=(2.5, 2.5, 1.1),
| ... focal_point=(0.0, 0.0, -0.3),
| ... viewup=(-0.25, -0.25, 1.0),
| ... )
| >>> pl.camera_position = cpos
| >>> pl.show()
|
| protein_ribbon(self, progress_bar: 'bool' = False)
| Generate protein ribbon.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Generated protein ribbon.
|
| Examples
| --------
| Generate protein ribbon.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> tgqp = examples.download_3gqp()
| >>> ribbon = tgqp.protein_ribbon()
| >>> ribbon.plot()
|
| ray_trace(self: 'PolyData', origin, end_point, first_point: 'bool' = False, plot: 'bool' = False, off_screen=None)
| Perform a single ray trace calculation.
|
| This requires a mesh and a line segment defined by an origin
| and end_point.
|
| .. warning::
|
| This filter uses the mesh's :attr:`~pyvista.PolyData.obbTree` property internally to
| compute the intersection. Since the obb tree is cached, the intersection may not be
| valid if the mesh's geometry is modified in between filter calls.
|
| Parameters
| ----------
| origin : sequence[float]
| Start of the line segment.
|
| end_point : sequence[float]
| End of the line segment.
|
| first_point : bool, default: False
| Returns intersection of first point only.
|
| plot : bool, default: False
| Whether to plot the ray trace results.
|
| off_screen : bool, optional
| Plots off screen when ``plot=True``. Used for unit testing.
|
| Returns
| -------
| intersection_points : numpy.ndarray
| Location of the intersection points. Empty array if no
| intersections.
|
| intersection_cells : numpy.ndarray
| Indices of the intersection cells. Empty array if no
| intersections.
|
| See Also
| --------
| :ref:`ray_trace_moeller_example`
| Example of ray-tracing using the Moeller-Trumbore intersection algorithm.
|
| Examples
| --------
| Compute the intersection between a ray from the origin to
| ``[1, 0, 0]`` and a sphere with radius 0.5 centered at the
| origin.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> point, cell = sphere.ray_trace([0, 0, 0], [1, 0, 0], first_point=True)
| >>> f'Intersected at {point[0]:.3f} {point[1]:.3f} {point[2]:.3f}'
| 'Intersected at 0.499 0.000 0.000'
|
| Show a plot of the ray trace.
|
| >>> point, cell = sphere.ray_trace([0, 0, 0], [1, 0, 0], plot=True)
|
| See :ref:`ray_trace_example` for more examples using this filter.
|
| reconstruct_surface(self, nbr_sz=None, sample_spacing=None, progress_bar: 'bool' = False)
| Reconstruct a surface from the points in this dataset.
|
| This filter takes a list of points assumed to lie on the
| surface of a solid 3D object. A signed measure of the distance
| to the surface is computed and sampled on a regular grid. The
| grid can then be contoured at zero to extract the surface. The
| default values for neighborhood size and sample spacing should
| give reasonable results for most uses but can be set if
| desired.
|
| This is helpful when generating surfaces from point clouds and
| is more reliable than :func:`DataSetFilters.delaunay_3d`.
|
| Parameters
| ----------
| nbr_sz : int, optional
| Specify the number of neighbors each point has, used for
| estimating the local surface orientation.
|
| The default value of 20 should be fine for most
| applications, higher values can be specified if the spread
| of points is uneven. Values as low as 10 may yield
| adequate results for some surfaces. Higher values cause
| the algorithm to take longer and will cause
| errors on sharp boundaries.
|
| sample_spacing : float, optional
| The spacing of the 3D sampling grid. If not set, a
| reasonable guess will be made.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Reconstructed surface.
|
| Examples
| --------
| Create a point cloud out of a sphere and reconstruct a surface
| from it.
|
| >>> import pyvista as pv
| >>> points = pv.wrap(pv.Sphere().points)
| >>> surf = points.reconstruct_surface()
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(points)
| >>> _ = pl.add_title('Point Cloud of 3D Surface')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(surf, color=True, show_edges=True)
| >>> _ = pl.add_title('Reconstructed Surface')
| >>> pl.show()
|
| See :ref:`surface_reconstruction_example` for more examples
| using this filter.
|
| remove_points(self, remove, mode='any', keep_scalars: 'bool' = True, inplace: 'bool' = False)
| Rebuild a mesh by removing points.
|
| Only valid for all-triangle meshes.
|
| Parameters
| ----------
| remove : sequence[bool | int]
| If remove is a bool array, points that are ``True`` will
| be removed. Otherwise, it is treated as a list of
| indices.
|
| mode : str, default: "any"
| When ``'all'``, only faces containing all points flagged
| for removal will be removed.
|
| keep_scalars : bool, default: True
| When ``True``, point and cell scalars will be passed on to
| the new mesh.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PolyData
| Mesh without the points flagged for removal.
|
| numpy.ndarray
| Indices of new points relative to the original mesh.
|
| Examples
| --------
| Remove the first 100 points from a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> reduced_sphere, ridx = sphere.remove_points(range(100, 250))
| >>> reduced_sphere.plot(show_edges=True, line_width=3)
|
| remove_unused_points(self: '_PolyDataType', *, inplace: 'bool' = False) -> '_PolyDataType'
| Remove points which are not used by any cells.
|
| This filter is similar to :meth:`clean` but does `not` merge points or convert cells.
| The point order is also unchanged by this filter.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy is returned.
|
| See Also
| --------
| pyvista.UnstructuredGridFilters.remove_unused_points
|
| Returns
| -------
| PolyData
| Mesh with unused points removed.
|
| Examples
| --------
| Create :class:`~pyvista.PolyData` with three points. The first two points are coincident
| and associated with :attr:`~pyvista.CellType.VERTEX` cells, and the third point is
| "unused" and not associated with any cells.
|
| >>> import pyvista as pv
| >>> points = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]
| >>> faces = [1, 0, 1, 1]
| >>> poly = pv.PolyData(points, faces)
| >>> poly
| PolyData (...)
| N Cells: 2
| N Points: 3
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 1.000e+00
| N Arrays: 0
|
| Since the third point is unused, we can remove it. Note that coincident points are `not`
| merged by this filter, so the two vertex points are kept as-is.
|
| >>> poly = poly.remove_unused_points()
| >>> poly
| PolyData (...)
| N Cells: 2
| N Points: 2
| N Strips: 0
| X Bounds: 0.000e+00, 0.000e+00
| Y Bounds: 0.000e+00, 0.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| N Arrays: 0
|
| ribbon(self, width=None, scalars=None, angle=0.0, factor=2.0, normal=None, tcoords: 'bool | str' = False, preference='points', progress_bar: 'bool' = False)
| Create a ribbon of the lines in this dataset.
|
| .. note::
| If there are no lines in the input dataset, then the output
| will be an empty :class:`pyvista.PolyData` mesh.
|
| Parameters
| ----------
| width : float, optional
| Set the "half" width of the ribbon. If the width is
| allowed to vary, this is the minimum width. The default is
| 10% the length.
|
| scalars : str, optional
| String name of the scalars array to use to vary the ribbon
| width. This is only used if a scalars array is specified.
|
| angle : float, optional
| Angle in degrees of the offset angle of the ribbon from
| the line normal. The default is 0.0.
|
| factor : float, optional
| Set the maximum ribbon width in terms of a multiple of the
| minimum width. The default is 2.0.
|
| normal : sequence[float], optional
| Normal to use as default.
|
| tcoords : bool, str, optional
| If ``True``, generate texture coordinates along the
| ribbon. This can also be specified to generate the texture
| coordinates with either ``'length'`` or ``'normalized'``.
|
| preference : str, optional
| The field preference when searching for the scalars array by
| name.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Ribbon mesh. Empty if there are no lines in the input dataset.
|
| Examples
| --------
| Convert a line to a ribbon and plot it.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> n = 1000
| >>> theta = np.linspace(-10 * np.pi, 10 * np.pi, n)
| >>> z = np.linspace(-2, 2, n)
| >>> r = z**2 + 1
| >>> x = r * np.sin(theta)
| >>> y = r * np.cos(theta)
| >>> points = np.column_stack((x, y, z))
| >>> pdata = pv.PolyData(points)
| >>> pdata.lines = np.hstack((n, range(n)))
| >>> pdata['distance'] = range(n)
| >>> ribbon = pdata.ribbon(width=0.2)
| >>> ribbon.plot(show_scalar_bar=False)
|
| ruled_surface(self, *, resolution: 'VectorLike[int] | None' = None, progress_bar: 'bool' = False)
| Create a ruled surface from a polyline.
|
| .. versionadded:: 0.45.0
|
| This filter is a filter that generates a surface from
| a set of lines. The lines are assumed to be "parallel"
| in the sense that they do not intersect and remain
| somewhat close to one another. A surface is generated
| by connecting the points defining each pair of lines
| with straight lines. This creates a strip for each pair
| of lines (i.e., a triangulation is created from two
| generating lines). The filter can handle an arbitrary
| number of lines, with lines i and i+1 assumed
| connected. Note that there are several different
| approaches for creating the ruled surface, the method
| for creating the surface can either use the input points
| or resample from the polylines (using a user-specified
| resolution).
|
| This filter implements :vtk:`vtkRuledSurfaceFilter`.
|
| Parameters
| ----------
| resolution : int, default: (1, 1)
| Set the number of points in the output polyline.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Ruled surface.
|
| Examples
| --------
| Create a ruled surface from a polyline.
|
| >>> import pyvista as pv
| >>> pl = pv.Plotter()
| >>> poly = pv.PolyData(
| ... [[0, 0, 1], [1, 0, 0], [0, 1, 0], [1, 1, 1]],
| ... lines=[[2, 0, 1], [2, 2, 3]],
| ... force_float=False,
| ... )
| >>> surface = poly.ruled_surface(resolution=(21, 21))
| >>> _ = pl.add_mesh(surface, show_edges=True)
| >>> pl.show()
|
| smooth(self, n_iter=20, relaxation_factor=0.01, convergence=0.0, edge_angle=15, feature_angle=45, boundary_smoothing: 'bool' = True, feature_smoothing: 'bool' = False, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Adjust point coordinates using Laplacian smoothing.
|
| The effect is to "relax" the mesh, making the cells better shaped and
| the vertices more evenly distributed.
|
| Parameters
| ----------
| n_iter : int, default: 20
| Number of iterations for Laplacian smoothing.
|
| relaxation_factor : float, default: 0.01
| Relaxation factor controls the amount of displacement in a single
| iteration. Generally a lower relaxation factor and higher number of
| iterations is numerically more stable.
|
| convergence : float, default: 0.0
| Convergence criterion for the iteration process. Smaller numbers
| result in more smoothing iterations. Range from (0 to 1).
|
| edge_angle : float, default: 15
| Edge angle to control smoothing along edges (either interior or boundary).
|
| feature_angle : float, default: 45
| Feature angle for sharp edge identification.
|
| boundary_smoothing : bool, default: True
| Flag to control smoothing of boundary edges. When ``True``,
| boundary edges remain fixed.
|
| feature_smoothing : bool, default: False
| Flag to control smoothing of feature edges. When ``True``,
| boundary edges remain fixed as defined by ``feature_angle`` and
| ``edge_angle``.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Smoothed mesh.
|
| Examples
| --------
| Smooth the edges of an all triangular cube
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(5)
| >>> smooth_cube = cube.smooth(n_iter=1000, feature_smoothing=False)
| >>> n_edge_cells = cube.extract_feature_edges().n_cells
| >>> n_smooth_cells = smooth_cube.extract_feature_edges().n_cells
| >>> f'Sharp Edges on Cube: {n_edge_cells}'
| 'Sharp Edges on Cube: 384'
| >>> f'Sharp Edges on Smooth Cube: {n_smooth_cells}'
| 'Sharp Edges on Smooth Cube: 12'
| >>> smooth_cube.plot()
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| smooth_taubin(self, n_iter=20, pass_band=0.1, edge_angle=15.0, feature_angle=45.0, boundary_smoothing: 'bool' = True, feature_smoothing: 'bool' = False, non_manifold_smoothing: 'bool' = False, normalize_coordinates: 'bool' = False, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Smooth a PolyData DataSet with Taubin smoothing.
|
| This filter allows you to smooth the mesh as in the Laplacian smoothing
| implementation in :func:`smooth() <PolyDataFilters.smooth>`. However,
| unlike Laplacian smoothing the surface does not "shrink" since this
| filter relies on an alternative approach to smoothing. This filter is
| more akin to a low pass filter where undesirable high frequency features
| are removed.
|
| This PyVista filter uses the VTK :vtk:`vtkWindowedSincPolyDataFilter`
| filter.
|
| Parameters
| ----------
| n_iter : int, default: 20
| This is the degree of the polynomial used to approximate the
| windowed sync function. This is generally much less than the number
| needed by :func:`smooth() <PolyDataFilters.smooth>`.
|
| pass_band : float, default: 0.1
| The passband value for the windowed sinc filter. This should be
| between 0 and 2, where lower values cause more smoothing.
|
| edge_angle : float, default: 15.0
| Edge angle to control smoothing along edges (either interior or
| boundary).
|
| feature_angle : float, default: 45.0
| Feature angle for sharp edge identification.
|
| boundary_smoothing : bool, default: True
| Flag to control smoothing of boundary edges. When ``True``,
| boundary edges remain fixed.
|
| feature_smoothing : bool, default: False
| Flag to control smoothing of feature edges. When ``True``,
| boundary edges remain fixed as defined by ``feature_angle`` and
| ``edge_angle``.
|
| non_manifold_smoothing : bool, default: False
| Smooth non-manifold points.
|
| normalize_coordinates : bool, default: False
| Flag to control coordinate normalization. To improve the
| numerical stability of the solution and minimize the scaling of the
| translation effects, the algorithm can translate and scale the
| position coordinates to within the unit cube ``[-1, 1]``, perform the
| smoothing, and translate and scale the position coordinates back to
| the original coordinate frame.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Smoothed mesh.
|
| Notes
| -----
| For maximum performance, do not enable ``feature_smoothing`` or
| ``boundary_smoothing``. ``feature_smoothing`` is especially expensive.
|
| References
| ----------
| See `Optimal Surface Smoothing as Filter Design
| <https://dl.acm.org/doi/pdf/10.1145/218380.218473>`_ for details
| regarding the implementation of Taubin smoothing.
|
| Examples
| --------
| Smooth the example bone mesh. Here, it's necessary to subdivide the
| mesh to increase the number of faces as the original mesh is so coarse.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_foot_bones().subdivide(2)
| >>> smoothed_mesh = mesh.smooth_taubin()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_text('Original Mesh')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(smoothed_mesh)
| >>> _ = pl.add_text('Smoothed Mesh')
| >>> pl.show()
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| strip(self, join: 'bool' = False, max_length=1000, pass_cell_data: 'bool' = False, pass_cell_ids: 'bool' = False, pass_point_ids: 'bool' = False, progress_bar: 'bool' = False)
| Strip poly data cells.
|
| Generates triangle strips and/or poly-lines from input
| polygons, triangle strips, and lines.
|
| Polygons are assembled into triangle strips only if they are
| triangles; other types of polygons are passed through to the
| output and not stripped. (Use ``triangulate`` filter to
| triangulate non-triangular polygons prior to running this
| filter if you need to strip all the data.) The filter will
| pass through (to the output) vertices if they are present in
| the input polydata.
|
| Also note that if triangle strips or polylines are defined in
| the input they are passed through and not joined nor
| extended. (If you wish to strip these use ``triangulate``
| filter to fragment the input into triangles and lines prior to
| running this filter.)
|
| This filter implements :vtk:`vtkStripper`.
|
| Parameters
| ----------
| join : bool, default: False
| If ``True``, the output polygonal segments will be joined
| if they are contiguous. This is useful after slicing a
| surface.
|
| max_length : int, default: 1000
| Specify the maximum number of triangles in a triangle
| strip, and/or the maximum number of lines in a poly-line.
|
| pass_cell_data : bool, default: False
| Enable/Disable passing of the CellData in the input to the
| output as FieldData. Note the field data is transformed.
|
| pass_cell_ids : bool, default: False
| If ``True``, the output polygonal dataset will have a
| celldata array that holds the cell index of the original
| 3D cell that produced each output cell. This is useful for
| picking. The default is ``False`` to conserve memory.
|
| pass_point_ids : bool, default: False
| If ``True``, the output polygonal dataset will have a
| pointdata array that holds the point index of the original
| vertex that produced each output vertex. This is useful
| for picking. The default is ``False`` to conserve memory.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Stripped mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> slc = mesh.slice(normal='z', origin=(0, 0, -10))
| >>> stripped = slc.strip()
| >>> stripped.n_cells
| 1
| >>> stripped.plot(show_edges=True, line_width=3)
|
| subdivide(self, nsub, subfilter='linear', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Increase the number of triangles in a single, connected triangular mesh.
|
| Uses one of the following vtk subdivision filters to subdivide a mesh:
|
| * :vtk:`vtkButterflySubdivisionFilter`
| * :vtk:`vtkLoopSubdivisionFilter`
| * :vtk:`vtkLinearSubdivisionFilter`
|
| Linear subdivision results in the fastest mesh subdivision,
| but it does not smooth mesh edges, but rather splits each
| triangle into 4 smaller triangles.
|
| Butterfly and loop subdivision perform smoothing when
| dividing, and may introduce artifacts into the mesh when
| dividing.
|
| .. note::
| Subdivision filter sometimes fails for multiple part
| meshes. The input should be one connected mesh.
|
| Parameters
| ----------
| nsub : int
| Number of subdivisions. Each subdivision creates 4 new
| triangles, so the number of resulting triangles is
| ``nface*4**nsub`` where ``nface`` is the current number of
| faces.
|
| subfilter : str, default: "linear"
| Can be one of the following:
|
| * ``'butterfly'``
| * ``'loop'``
| * ``'linear'``
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Subdivided mesh.
|
| Examples
| --------
| First, create an example coarse sphere mesh and plot it.
|
| >>> from pyvista import examples
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(phi_resolution=10, theta_resolution=10)
| >>> mesh.plot(show_edges=True, line_width=3)
|
| Subdivide the sphere mesh using linear subdivision.
|
| >>> submesh = mesh.subdivide(1, 'linear')
| >>> submesh.plot(show_edges=True, line_width=3)
|
| Subdivide the sphere mesh using loop subdivision.
|
| >>> submesh = mesh.subdivide(1, 'loop')
| >>> submesh.plot(show_edges=True, line_width=3)
|
| Subdivide the sphere mesh using butterfly subdivision.
|
| >>> submesh = mesh.subdivide(1, 'butterfly')
| >>> submesh.plot(show_edges=True, line_width=3)
|
| subdivide_adaptive(self, max_edge_len=None, max_tri_area=None, max_n_tris=None, max_n_passes=None, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Increase the number of triangles in a triangular mesh based on edge and/or area metrics.
|
| This filter uses a simple case-based, multi-pass approach to
| repeatedly subdivide the input triangle mesh to meet the area
| and/or edge length criteria. New points may be inserted only
| on edges; depending on the number of edges to be subdivided a
| different number of triangles are inserted ranging from two
| (i.e., two triangles replace the original one) to four.
|
| Point and cell data is treated as follows: The cell data from
| a parent triangle is assigned to its subdivided
| children. Point data is interpolated along edges as the edges
| are subdivided.
|
| This filter retains mesh watertightness if the mesh was
| originally watertight; and the area and max triangles criteria
| are not used.
|
| Parameters
| ----------
| max_edge_len : float, optional
| The maximum edge length that a triangle may have. Edges
| longer than this value are split in half and the
| associated triangles are modified accordingly.
|
| max_tri_area : float, optional
| The maximum area that a triangle may have. Triangles
| larger than this value are subdivided to meet this
| threshold. Note that if this criterion is used it may
| produce non-watertight meshes as a result.
|
| max_n_tris : int, optional
| The maximum number of triangles that can be created. If
| the limit is hit, it may result in premature termination
| of the algorithm and the results may be less than
| satisfactory (for example non-watertight meshes may be
| created). By default, the limit is set to a very large
| number (i.e., no effective limit).
|
| max_n_passes : int, optional
| The maximum number of passes (i.e., levels of
| subdivision). If the limit is hit, then the subdivision
| process stops and additional passes (needed to meet other
| criteria) are aborted. The default limit is set to a very
| large number (i.e., no effective limit).
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Subdivided mesh.
|
| Examples
| --------
| First, load the example airplane mesh and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.PolyData(examples.planefile)
| >>> mesh.plot(show_edges=True, line_width=3)
|
| Subdivide the mesh
|
| >>> submesh = mesh.subdivide_adaptive(max_n_passes=2)
| >>> submesh.plot(show_edges=True)
|
| triangulate(self, *, pass_verts: 'bool' = False, pass_lines: 'bool' = False, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| pass_verts : bool, default: False
| Whether vertices cells are passed to the output PolyData.
|
| .. versionadded:: 0.45.0
|
| pass_lines : bool, default: False
| Whether lines cells are passed to the output PolyData.
|
| .. versionadded:: 0.45.0
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| triangulate_contours(self: '_PolyDataType', display_errors: 'bool' = False, progress_bar: 'bool' = False) -> '_PolyDataType'
| Triangulate and fill all 2D contours to create polygons.
|
| .. versionadded:: 0.44.0
|
| This filter will generate triangles to fill all of the 2D contours
| in its input. The input to the filter is a set of lines (not polylines)
| which when joined form loops. The contours may be concave, and may even
| contain holes i.e. a contour may contain an internal contour that is
| wound in the opposite direction (as compared to the outer polygon
| normal) to indicate that it is a hole.
|
| .. note::
|
| This filter will assume that the input polygons lie in the same
| plane and will not perform any projection or transformation of the
| input data. You may need to project your data to a plane before
| using this filter.
|
| .. warning::
|
| The triangulation of is done in O(n) time for simple convex inputs,
| but for non-convex inputs the worst-case time is O(n^2*m^2) where n
| is the number of points and m is the number of holes. The best
| triangulation algorithms, in contrast, are O(n log n). The
| resulting triangles may be quite narrow, the algorithm does not
| attempt to produce high-quality triangles.
|
| Parameters
| ----------
| display_errors : bool, default: False
| Generate errors when the triangulation fails. Note that
| triangulation failures are often minor, because they involve tiny
| triangles that are too small to see.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Raises
| ------
| RuntimeError
| If the mesh does not contain lines.
|
| Returns
| -------
| pyvista.PolyData
| Triangulated mesh with the filled contours.
|
| Examples
| --------
| Create banded contour and fill.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.download_st_helens()
| >>> contours = image.contour([1302.3334, 1922.6666])
| >>> filled = contours.triangulate_contours()
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(image, show_scalar_bar=False)
| >>> _ = pl.add_mesh(contours, color='black')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(contours, color='black')
| >>> _ = pl.add_mesh(filled, color='red')
| >>> pl.link_views()
| >>> pl.view_xy()
| >>> pl.show()
|
| tube(self, radius=None, scalars=None, capping: 'bool' = True, n_sides=20, radius_factor=10.0, absolute: 'bool' = False, preference='point', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Generate a tube around each input line.
|
| The radius of the tube can be set to linearly vary with a
| scalar value.
|
| Parameters
| ----------
| radius : float, optional
| Minimum tube radius (minimum because the tube radius may
| vary).
|
| scalars : str, optional
| Scalars array by which the radius varies.
|
| capping : bool, default: True
| Turn on/off whether to cap the ends with polygons.
|
| n_sides : int, default: 20
| Set the number of sides for the tube. Minimum of 3.
|
| radius_factor : float, default: 10.0
| Maximum tube radius in terms of a multiple of the minimum
| radius.
|
| absolute : bool, default: False
| Vary the radius with values from scalars in absolute units.
|
| preference : str, default: 'point'
| The field preference when searching for the scalars array by
| name.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Tube-filtered mesh.
|
| Examples
| --------
| Convert a single line to a tube.
|
| >>> import pyvista as pv
| >>> line = pv.Line()
| >>> tube = line.tube(radius=0.02)
| >>> f'Line Cells: {line.n_cells}'
| 'Line Cells: 1'
| >>> f'Tube Cells: {tube.n_cells}'
| 'Tube Cells: 22'
| >>> tube.plot(color='lightblue')
|
| See :ref:`create_spline_example` for more examples using this filter.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
pyvista.PolyDataWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.Polygon
Python Library Documentation: function Polygon in module pyvista.core.utilities.geometric_objects
Polygon(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), radius: 'float' = 1.0, normal: 'VectorLike[float]' = (0.0, 0.0, 1.0), n_sides: 'int' = 6, fill: 'bool' = True) -> 'PolyData'
Create a polygon.
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Center in ``[x, y, z]``. Central axis of the polygon passes
through this point.
radius : float, default: 1.0
The radius of the polygon.
normal : sequence[float], default: (0.0, 0.0, 1.0)
Direction vector in ``[x, y, z]``. Orientation vector of the polygon.
n_sides : int, default: 6
Number of sides of the polygon.
fill : bool, default: True
Enable or disable producing filled polygons.
Returns
-------
pyvista.PolyData
Mesh of the polygon.
Examples
--------
Create an 8 sided polygon.
>>> import pyvista as pv
>>> mesh = pv.Polygon(n_sides=8)
>>> mesh.plot(show_edges=True, line_width=5)
pyvista.PolygonSource
Python Library Documentation: class PolygonSource in module pyvista.core.utilities.geometric_sources
class PolygonSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkRegularPolygonSource)
| PolygonSource(*args, **kwargs) -> '_T'
|
| Polygon source algorithm class.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Center in ``[x, y, z]``. Central axis of the polygon passes
| through this point.
|
| radius : float, default: 1.0
| The radius of the polygon.
|
| normal : sequence[float], default: (0.0, 0.0, 1.0)
| Direction vector in ``[x, y, z]``. Orientation vector of the polygon.
|
| n_sides : int, default: 6
| Number of sides of the polygon.
|
| fill : bool, default: True
| Enable or disable producing filled polygons.
|
| Examples
| --------
| Create an 8 sided polygon.
|
| >>> import pyvista as pv
| >>> source = pv.PolygonSource(n_sides=8)
| >>> source.output.plot(show_edges=True, line_width=5)
|
| Method resolution order:
| PolygonSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkRegularPolygonSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'PolygonSource', center: 'VectorLike[float]' = (0.0, 0.0, 0.0), radius: 'float' = 1.0, normal: 'VectorLike[float]' = (0.0, 0.0, 1.0), n_sides: 'int' = 6, fill: 'bool' = True) -> 'None'
| Initialize the polygon source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Polygon surface.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Get the center in ``[x, y, z]``.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``.
|
| fill
| Get enable or disable producing filled polygons.
|
| Returns
| -------
| bool
| Enable or disable producing filled polygons.
|
| n_sides
| Get number of sides of the polygon.
|
| Returns
| -------
| int
| Number of sides of the polygon.
|
| normal
| Get the normal in ``[x, y, z]``.
|
| Returns
| -------
| sequence[float]
| Normal in ``[x, y, z]``.
|
| radius
| Get the radius of the polygon.
|
| Returns
| -------
| float
| The radius of the polygon.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkRegularPolygonSource:
|
| GeneratePolygonOff(...)
| GeneratePolygonOff(self) -> None
| C++: virtual void GeneratePolygonOff()
|
| GeneratePolygonOn(...)
| GeneratePolygonOn(self) -> None
| C++: virtual void GeneratePolygonOn()
|
| GeneratePolylineOff(...)
| GeneratePolylineOff(self) -> None
| C++: virtual void GeneratePolylineOff()
|
| GeneratePolylineOn(...)
| GeneratePolylineOn(self) -> None
| C++: virtual void GeneratePolylineOn()
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetGeneratePolygon(...)
| GetGeneratePolygon(self) -> int
| C++: virtual vtkTypeBool GetGeneratePolygon()
|
| GetGeneratePolyline(...)
| GetGeneratePolyline(self) -> int
| C++: virtual vtkTypeBool GetGeneratePolyline()
|
| GetNormal(...)
| GetNormal(self) -> (float, float, float)
| C++: virtual double *GetNormal()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfSides(...)
| GetNumberOfSides(self) -> int
| C++: virtual int GetNumberOfSides()
|
| GetNumberOfSidesMaxValue(...)
| GetNumberOfSidesMaxValue(self) -> int
| C++: virtual int GetNumberOfSidesMaxValue()
|
| GetNumberOfSidesMinValue(...)
| GetNumberOfSidesMinValue(self) -> int
| C++: virtual int GetNumberOfSidesMinValue()
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetRadius(...)
| GetRadius(self) -> float
| C++: virtual double GetRadius()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkRegularPolygonSource
| C++: vtkRegularPolygonSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkRegularPolygonSource
| C++: static vtkRegularPolygonSource *SafeDownCast(
| vtkObjectBase *o)
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set/Get the center of the polygon. By default, the center is set
| at the origin (0,0,0).
|
| SetGeneratePolygon(...)
| SetGeneratePolygon(self, _arg:int) -> None
| C++: virtual void SetGeneratePolygon(vtkTypeBool _arg)
|
| Control whether a polygon is produced. By default,
| GeneratePolygon is enabled.
|
| SetGeneratePolyline(...)
| SetGeneratePolyline(self, _arg:int) -> None
| C++: virtual void SetGeneratePolyline(vtkTypeBool _arg)
|
| Control whether a polyline is produced. By default,
| GeneratePolyline is enabled.
|
| SetNormal(...)
| SetNormal(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetNormal(double _arg1, double _arg2,
| double _arg3)
| SetNormal(self, _arg:(float, float, float)) -> None
| C++: virtual void SetNormal(const double _arg[3])
|
| Set/Get the normal to the polygon. The ordering of the polygon
| will be counter-clockwise around the normal (i.e., using the
| right-hand rule). By default, the normal is set to (0,0,1).
|
| SetNumberOfSides(...)
| SetNumberOfSides(self, _arg:int) -> None
| C++: virtual void SetNumberOfSides(int _arg)
|
| Set/Get the number of sides of the polygon. By default, the
| number of sides is set to six.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetRadius(...)
| SetRadius(self, _arg:float) -> None
| C++: virtual void SetRadius(double _arg)
|
| Set/Get the radius of the polygon. By default, the radius is set
| to 0.5.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkRegularPolygonSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkRegularPolygonSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkRegularPolygonSource:
|
| __this__
| Pointer to the C++ object.
|
| generate_polygon
| read-write, calls GetGeneratePolygon/SetGeneratePolygon
|
| generate_polyline
| read-write, calls GetGeneratePolyline/SetGeneratePolyline
|
| number_of_sides
| read-write, calls GetNumberOfSides/SetNumberOfSides
|
| number_of_sides_max_value
| read-only, calls GetNumberOfSidesMaxValue
|
| number_of_sides_min_value
| read-only, calls GetNumberOfSidesMinValue
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkRegularPolygonSource:
|
| __vtkname__ = 'vtkRegularPolygonSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.ProStarReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.ProgressMonitor
Python Library Documentation: class ProgressMonitor in module pyvista.core.utilities.observers
class ProgressMonitor(pyvista.core.utilities.misc._NoNewAttrMixin)
| ProgressMonitor(*args, **kwargs) -> '_T'
|
| A standard class for monitoring the progress of a VTK algorithm.
|
| This must be use in a ``with`` context and it will block keyboard
| interrupts from happening until the exit event as interrupts will crash
| the kernel if the VTK algorithm is still executing.
|
| Parameters
| ----------
| algorithm
| VTK algorithm or filter.
|
| message : str, default: ""
| Message to display in the progress bar.
|
| Method resolution order:
| ProgressMonitor
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| __call__(self, obj, *args) -> 'None'
| Call progress update callback.
|
| On an event occurrence, this function executes.
|
| __enter__(self)
| Enter event for ``with`` context.
|
| __exit__(self, *args) -> 'None'
| Exit event for ``with`` context.
|
| __init__(self, algorithm, message='')
| Initialize observer.
|
| handler(self, sig, frame) -> 'None'
| Pass signal to custom interrupt handler.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
pyvista.PyVistaAttributeError
Python Library Documentation: class PyVistaAttributeError in module pyvista.core.errors class PyVistaAttributeError(builtins.AttributeError) | PyVistaAttributeError(message='The attribute is not part of the PyVista API') -> 'None' | | Exception when accessing an attribute that is not part of the PyVista API. | | Parameters | ---------- | message : str | Error message. | | Method resolution order: | PyVistaAttributeError | builtins.AttributeError | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, message='The attribute is not part of the PyVista API') -> 'None' | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Methods inherited from builtins.AttributeError: | | __getstate__(...) | Helper for pickle. | | __reduce__(...) | Helper for pickle. | | __str__(self, /) | Return str(self). | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.AttributeError: | | name | attribute name | | obj | object | | ---------------------------------------------------------------------- | Static methods inherited from builtins.Exception: | | __new__(*args, **kwargs) class method of builtins.Exception | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.PyVistaDeprecationWarning
Python Library Documentation: class PyVistaDeprecationWarning in module pyvista.core.errors class PyVistaDeprecationWarning(builtins.Warning) | Non-supressed Deprecation Warning. | | Method resolution order: | PyVistaDeprecationWarning | builtins.Warning | builtins.Exception | builtins.BaseException | builtins.object | | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Methods inherited from builtins.Warning: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.Warning: | | __new__(*args, **kwargs) class method of builtins.Warning | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.PyVistaEfficiencyWarning
Python Library Documentation: class PyVistaEfficiencyWarning in module pyvista.core.errors class PyVistaEfficiencyWarning(builtins.Warning) | Efficiency warning. | | Method resolution order: | PyVistaEfficiencyWarning | builtins.Warning | builtins.Exception | builtins.BaseException | builtins.object | | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Methods inherited from builtins.Warning: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.Warning: | | __new__(*args, **kwargs) class method of builtins.Warning | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.PyVistaFutureWarning
Python Library Documentation: class PyVistaFutureWarning in module pyvista.core.errors class PyVistaFutureWarning(builtins.Warning) | Non-supressed Future Warning. | | Method resolution order: | PyVistaFutureWarning | builtins.Warning | builtins.Exception | builtins.BaseException | builtins.object | | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Methods inherited from builtins.Warning: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.Warning: | | __new__(*args, **kwargs) class method of builtins.Warning | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.PyVistaPipelineError
Python Library Documentation: class PyVistaPipelineError in module pyvista.core.errors class PyVistaPipelineError(builtins.RuntimeError) | PyVistaPipelineError(message='VTK pipeline issue detected by PyVista.') -> 'None' | | Exception when a VTK pipeline runs into an issue. | | Parameters | ---------- | message : str | Error message. | | Method resolution order: | PyVistaPipelineError | builtins.RuntimeError | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, message='VTK pipeline issue detected by PyVista.') -> 'None' | Call the base class constructor with the custom message. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Static methods inherited from builtins.RuntimeError: | | __new__(*args, **kwargs) class method of builtins.RuntimeError | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.Pyramid
Python Library Documentation: function Pyramid in module pyvista.core.utilities.geometric_objects
Pyramid(points: 'MatrixLike[float] | None' = None) -> 'UnstructuredGrid'
Create a pyramid defined by 5 points.
Parameters
----------
points : array_like[float], optional
Points of the pyramid. Points are ordered such that the first
four points are the four counterclockwise points on the
quadrilateral face, and the last point is the apex.
Defaults to pyramid in example.
Returns
-------
pyvista.UnstructuredGrid
Unstructured grid containing a single pyramid cell.
Examples
--------
>>> import pyvista as pv
>>> pointa = [1.0, 1.0, 0.0]
>>> pointb = [-1.0, 1.0, 0.0]
>>> pointc = [-1.0, -1.0, 0.0]
>>> pointd = [1.0, -1.0, 0.0]
>>> pointe = [0.0, 0.0, 1.608]
>>> pyramid = pv.Pyramid([pointa, pointb, pointc, pointd, pointe])
>>> pyramid.plot(show_edges=True, line_width=5)
pyvista.Quadrilateral
Python Library Documentation: function Quadrilateral in module pyvista.core.utilities.geometric_objects
Quadrilateral(points: 'MatrixLike[float] | None' = None) -> 'PolyData'
Create a quadrilateral defined by 4 points.
Parameters
----------
points : array_like[float], optional
Points of the quadrilateral. Defaults to a unit square in xy-plane.
Returns
-------
pyvista.PolyData
Quadrilateral mesh.
Examples
--------
>>> import pyvista as pv
>>> pointa = [1.0, 0.0, 0.0]
>>> pointb = [1.0, 1.0, 0.0]
>>> pointc = [0.0, 1.0, 0.0]
>>> pointd = [0.0, 0.0, 0.0]
>>> quadrilateral = pv.Quadrilateral([pointa, pointb, pointc, pointd])
>>> quadrilateral.plot(show_edges=True, line_width=5)
pyvista.REPR_VOLUME_MAX_CELLS
Python Library Documentation: float object
class float(object)
| float(x=0, /)
|
| Convert a string or number to a floating-point number, if possible.
|
| Methods defined here:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __bool__(self, /)
| True if self else False
|
| __ceil__(self, /)
| Return the ceiling as an Integral.
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __eq__(self, value, /)
| Return self==value.
|
| __float__(self, /)
| float(self)
|
| __floor__(self, /)
| Return the floor as an Integral.
|
| __floordiv__(self, value, /)
| Return self//value.
|
| __format__(self, format_spec, /)
| Formats the float according to format_spec.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __int__(self, /)
| int(self)
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __mod__(self, value, /)
| Return self%value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __neg__(self, /)
| -self
|
| __pos__(self, /)
| +self
|
| __pow__(self, value, mod=None, /)
| Return pow(self, value, mod).
|
| __radd__(self, value, /)
| Return value+self.
|
| __rdivmod__(self, value, /)
| Return divmod(value, self).
|
| __repr__(self, /)
| Return repr(self).
|
| __rfloordiv__(self, value, /)
| Return value//self.
|
| __rmod__(self, value, /)
| Return value%self.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __round__(self, ndigits=None, /)
| Return the Integral closest to x, rounding half toward even.
|
| When an argument is passed, work like built-in round(x, ndigits).
|
| __rpow__(self, value, mod=None, /)
| Return pow(value, self, mod).
|
| __rsub__(self, value, /)
| Return value-self.
|
| __rtruediv__(self, value, /)
| Return value/self.
|
| __sub__(self, value, /)
| Return self-value.
|
| __truediv__(self, value, /)
| Return self/value.
|
| __trunc__(self, /)
| Return the Integral closest to x between 0 and x.
|
| as_integer_ratio(self, /)
| Return a pair of integers, whose ratio is exactly equal to the original float.
|
| The ratio is in lowest terms and has a positive denominator. Raise
| OverflowError on infinities and a ValueError on NaNs.
|
| >>> (10.0).as_integer_ratio()
| (10, 1)
| >>> (0.0).as_integer_ratio()
| (0, 1)
| >>> (-.25).as_integer_ratio()
| (-1, 4)
|
| conjugate(self, /)
| Return self, the complex conjugate of any float.
|
| hex(self, /)
| Return a hexadecimal representation of a floating-point number.
|
| >>> (-0.1).hex()
| '-0x1.999999999999ap-4'
| >>> 3.14159.hex()
| '0x1.921f9f01b866ep+1'
|
| is_integer(self, /)
| Return True if the float is an integer.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __getformat__(typestr, /)
| You probably don't want to use this function.
|
| typestr
| Must be 'double' or 'float'.
|
| It exists mainly to be used in Python's test suite.
|
| This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,
| little-endian' best describes the format of floating-point numbers used by the
| C type named by typestr.
|
| fromhex(string, /)
| Create a floating-point number from a hexadecimal string.
|
| >>> float.fromhex('0x1.ffffp10')
| 2047.984375
| >>> float.fromhex('-0x1p-1074')
| -5e-324
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| imag
| the imaginary part of a complex number
|
| real
| the real part of a complex number
pyvista.ReaderRegistration
Python Library Documentation: class ReaderRegistration in module pyvista.core.utilities.reader_registry
class ReaderRegistration(builtins.tuple)
| ReaderRegistration(extension: ForwardRef('str'), handler: ForwardRef('ReaderHandler'), source: ForwardRef('str'))
|
| Describe one registered custom reader.
|
| Returned by :func:`~pyvista.registered_readers`.
|
| .. versionadded:: 0.48.0
|
| Attributes
| ----------
| extension : str
| File extension the reader is registered against, including the
| leading dot (e.g. ``'.myformat'``).
| handler : callable
| The reader callable.
| source : str
| Human-readable origin in the form ``'module.qualname'`` for
| explicit registrations or the entry-point ``value`` for
| plugin-discovered registrations.
|
| Method resolution order:
| ReaderRegistration
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.ReaderRegistration
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.ReaderRegistration
| Return a nicely formatted representation string
|
| _asdict(self) from collections.ReaderRegistration
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.ReaderRegistration
| Return a new ReaderRegistration object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.ReaderRegistration
| Make a new ReaderRegistration object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, extension: ForwardRef('str'), handler: ForwardRef('ReaderHandler'), source: ForwardRef('str')) from namedtuple_ReaderRegistration.ReaderRegistration
| Create new instance of ReaderRegistration(extension, handler, source)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| extension
| Alias for field number 0
|
| handler
| Alias for field number 1
|
| source
| Alias for field number 2
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'extension': ForwardRef('str'), 'handler': ForwardR...
|
| __match_args__ = ('extension', 'handler', 'source')
|
| __orig_bases__ = (<function NamedTuple>,)
|
| _field_defaults = {}
|
| _fields = ('extension', 'handler', 'source')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
pyvista.Rectangle
Python Library Documentation: function Rectangle in module pyvista.core.utilities.geometric_objects
Rectangle(points: 'MatrixLike[float] | None' = None) -> 'PolyData'
Create a rectangle defined by 3 points.
The 3 points must define an orthogonal set of vectors.
Parameters
----------
points : array_like[float], optional
Points of the rectangle. Defaults to a unit square in xy-plane.
Returns
-------
pyvista.PolyData
Rectangle mesh.
Examples
--------
>>> import pyvista as pv
>>> pointa = [1.0, 0.0, 0.0]
>>> pointb = [1.0, 1.0, 0.0]
>>> pointc = [0.0, 1.0, 0.0]
>>> rectangle = pv.Rectangle([pointa, pointb, pointc])
>>> rectangle.plot(show_edges=True, line_width=5)
pyvista.RectilinearGrid
Python Library Documentation: class RectilinearGrid in module pyvista.core.grid
class RectilinearGrid(Grid, pyvista.core.filters.rectilinear_grid.RectilinearGridFilters, vtkmodules.vtkCommonDataModel.vtkRectilinearGrid)
| RectilinearGrid(*args, **kwargs) -> '_T'
|
| Dataset with variable spacing in the three coordinate directions.
|
| Can be initialized in several ways:
|
| * Create empty grid
| * Initialize from a :vtk:`vtkRectilinearGrid` object
| * Initialize directly from the point arrays
|
| Parameters
| ----------
| uinput : str, pathlib.Path, :vtk:`vtkRectilinearGrid`, numpy.ndarray, optional
| Filename, dataset, or array to initialize the rectilinear grid from. If a
| filename is passed, pyvista will attempt to load it as a
| :class:`RectilinearGrid`. If passed a :vtk:`vtkRectilinearGrid`, it
| will be wrapped. If a :class:`numpy.ndarray` is passed, this will be
| loaded as the x range.
|
| y : numpy.ndarray, optional
| Coordinates of the points in y direction. If this is passed, ``uinput``
| must be a :class:`numpy.ndarray`.
|
| z : numpy.ndarray, optional
| Coordinates of the points in z direction. If this is passed, ``uinput``
| and ``y`` must be a :class:`numpy.ndarray`.
|
| check_duplicates : bool, optional
| Check for duplications in any arrays that are passed. Defaults to
| ``False``. If ``True``, an error is raised if there are any duplicate
| values in any of the array-valued input arguments.
|
| deep : bool, optional
| Whether to deep copy a :vtk:`vtkRectilinearGrid` object.
| Default is ``False``. Keyword only.
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import vtk
| >>> import numpy as np
|
| Create an empty grid.
|
| >>> grid = pv.RectilinearGrid()
|
| Initialize from a :vtk:`vtkRectilinearGrid` object
|
| >>> vtkgrid = vtk.vtkRectilinearGrid()
| >>> grid = pv.RectilinearGrid(vtkgrid)
|
| Create from NumPy arrays.
|
| >>> xrng = np.arange(-10, 10, 2)
| >>> yrng = np.arange(-10, 10, 5)
| >>> zrng = np.arange(-10, 10, 1)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> grid.plot(show_edges=True)
|
| Method resolution order:
| RectilinearGrid
| Grid
| pyvista.core.dataset.DataSet
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| pyvista.core.filters.rectilinear_grid.RectilinearGridFilters
| vtkmodules.vtkCommonDataModel.vtkRectilinearGrid
| vtkmodules.vtkCommonDataModel.vtkCartesianGrid
| vtkmodules.vtkCommonDataModel.vtkDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'Self', *args, check_duplicates: 'bool' = False, deep: 'bool' = False, validate: 'bool | _NestedMeshValidationFields' = False, **kwargs) -> 'None'
| Initialize the rectilinear grid.
|
| __repr__(self: 'Self') -> 'str'
| Return the default representation.
|
| __str__(self: 'Self') -> 'str'
| Return the str representation.
|
| cast_to_structured_grid(self: 'Self') -> 'StructuredGrid'
| Cast this rectilinear grid to a :class:`~pyvista.StructuredGrid`.
|
| .. note::
|
| Casting converts :class:`~pyvista.CellType.PIXEL` cells to
| :class:`~pyvista.CellType.QUAD` cells for 2D inputs, and
| :class:`~pyvista.CellType.VOXEL` cells to :class:`~pyvista.CellType.HEXAHEDRON` cells
| for 3D inputs. To preserve cell type, use
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` instead.
|
| Returns
| -------
| pyvista.StructuredGrid
| This grid as a structured grid.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| meshgrid
| Return a meshgrid of numpy arrays for this mesh.
|
| This simply returns a :func:`numpy.meshgrid` of the
| coordinates for this mesh in ``ij`` indexing. These are a copy
| of the points of this mesh.
|
| Returns
| -------
| tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]
| Tuple of numpy arrays representing the points of this mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| dimensions
| Return the grid's dimensions.
|
| These are effectively the number of points along each of the
| three dataset axes.
|
| Returns
| -------
| tuple[int]
| Dimensions of the grid.
|
| Examples
| --------
| Create a uniform grid with dimensions ``(1, 2, 3)``.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(2, 3, 4))
| >>> grid.dimensions
| (2, 3, 4)
| >>> grid.plot(show_edges=True)
|
| Set the dimensions to ``(3, 4, 5)``
|
| >>> grid.dimensions = (3, 4, 5)
| >>> grid.plot(show_edges=True)
|
| points
| Return a copy of the points as an ``(n, 3)`` numpy array.
|
| Returns
| -------
| numpy.ndarray
| Array of points.
|
| Notes
| -----
| Points of a :class:`pyvista.RectilinearGrid` cannot be
| set. Set point coordinates with :attr:`RectilinearGrid.x`,
| :attr:`RectilinearGrid.y`, or :attr:`RectilinearGrid.z`.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.arange(-10, 10, 10, dtype=float)
| >>> yrng = np.arange(-10, 10, 10, dtype=float)
| >>> zrng = np.arange(-10, 10, 10, dtype=float)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> grid.points
| array([[-10., -10., -10.],
| [ 0., -10., -10.],
| [-10., 0., -10.],
| [ 0., 0., -10.],
| [-10., -10., 0.],
| [ 0., -10., 0.],
| [-10., 0., 0.],
| [ 0., 0., 0.]])
|
| x
| Return or set the coordinates along the X-direction.
|
| Returns
| -------
| numpy.ndarray
| Array of points along the X-direction.
|
| Examples
| --------
| Return the x coordinates of a RectilinearGrid.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.arange(-10, 10, 10, dtype=float)
| >>> yrng = np.arange(-10, 10, 10, dtype=float)
| >>> zrng = np.arange(-10, 10, 10, dtype=float)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> grid.x
| array([-10., 0.])
|
| Set the x coordinates of a RectilinearGrid.
|
| >>> grid.x = [-10.0, 0.0, 10.0]
| >>> grid.x
| array([-10., 0., 10.])
|
| y
| Return or set the coordinates along the Y-direction.
|
| Returns
| -------
| numpy.ndarray
| Array of points along the Y-direction.
|
| Examples
| --------
| Return the y coordinates of a RectilinearGrid.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.arange(-10, 10, 10, dtype=float)
| >>> yrng = np.arange(-10, 10, 10, dtype=float)
| >>> zrng = np.arange(-10, 10, 10, dtype=float)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> grid.y
| array([-10., 0.])
|
| Set the y coordinates of a RectilinearGrid.
|
| >>> grid.y = [-10.0, 0.0, 10.0]
| >>> grid.y
| array([-10., 0., 10.])
|
| z
| Return or set the coordinates along the Z-direction.
|
| Returns
| -------
| numpy.ndarray
| Array of points along the Z-direction.
|
| Examples
| --------
| Return the z coordinates of a RectilinearGrid.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.arange(-10, 10, 10, dtype=float)
| >>> yrng = np.arange(-10, 10, 10, dtype=float)
| >>> zrng = np.arange(-10, 10, 10, dtype=float)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> grid.z
| array([-10., 0.])
|
| Set the z coordinates of a RectilinearGrid.
|
| >>> grid.z = [-10.0, 0.0, 10.0]
| >>> grid.z
| array([-10., 0., 10.])
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| ----------------------------------------------------------------------
| Methods inherited from Grid:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| to_hexahedra(self: 'Self') -> 'UnstructuredGrid'
| Convert voxels to hexahedra.
|
| Convert this mesh to :class:`~pyvista.UnstructuredGrid` with
| :attr:`~pyvista.CellType.HEXAHEDRON` cells. Equivalent to
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` except the output has
| hexahedra instead of :attr:`~pyvista.CellType.VOXEL` cells.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with :attr:`~pyvista.CellType.HEXAHEDRON` cells.
|
| Raises
| ------
| ValueError
| If the input is not 3-dimensional.
|
| See Also
| --------
| to_quads, to_tetrahedra
| pyvista.DataSet.cast_to_unstructured_grid
|
| Examples
| --------
| Convert a 3D :class:`~pyvista.ImageData` to hexahedra.
|
| >>> import pyvista as pv
| >>> image = pv.ImageData(dimensions=(2, 2, 2))
| >>> hexes = image.to_hexahedra()
| >>> hexes.distinct_cell_types == {pv.CellType.HEXAHEDRON}
| True
|
| to_quads(self: 'Self') -> 'UnstructuredGrid'
| Convert pixels to quads.
|
| Convert this mesh to :class:`~pyvista.UnstructuredGrid` with
| :attr:`~pyvista.CellType.QUAD` cells. Equivalent to
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` except the output has
| quads instead of :attr:`~pyvista.CellType.PIXEL` cells.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with :attr:`~pyvista.CellType.QUAD` cells.
|
| Raises
| ------
| ValueError
| If the input is not 2-dimensional.
|
| See Also
| --------
| to_hexahedra, to_tetrahedra
| pyvista.DataSet.cast_to_unstructured_grid
|
| Examples
| --------
| Convert a 2D :class:`~pyvista.ImageData` to quads.
|
| >>> import pyvista as pv
| >>> image = pv.ImageData(dimensions=(3, 2, 1))
| >>> quads = image.to_quads()
| >>> quads.distinct_cell_types == {pv.CellType.QUAD}
| True
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.rectilinear_grid.RectilinearGridFilters:
|
| to_tetrahedra(self, tetra_per_cell: 'int' = 5, mixed: 'str | Sequence[int] | bool' = False, pass_cell_ids: 'bool' = True, pass_data: 'bool' = True, progress_bar: 'bool' = False)
| Create a tetrahedral mesh structured grid.
|
| Parameters
| ----------
| tetra_per_cell : int, default: 5
| The number of tetrahedrons to divide each cell into. Can be
| either ``5``, ``6``, or ``12``. If ``mixed=True``, this value is
| overridden.
|
| mixed : str, bool, sequence, default: False
| When set, subdivides some cells into 5 and some cells into 12. Set
| to ``True`` to use the active cell scalars of the
| :class:`pyvista.RectilinearGrid` to be either 5 or 12 to
| determining the number of tetrahedra to generate per cell.
|
| When a sequence, uses these values to subdivide the cells. When a
| string uses a cell array rather than the active array to determine
| the number of tetrahedra to generate per cell.
|
| pass_cell_ids : bool, default: True
| Set to ``True`` to make the tetrahedra have scalar data indicating
| which cell they came from in the original
| :class:`pyvista.RectilinearGrid`. The name of this array is
| ``'vtkOriginalCellIds'`` within the ``cell_data``.
|
| pass_data : bool, default: True
| Set to ``True`` to make the tetrahedra mesh have the cell data from
| the original :class:`pyvista.RectilinearGrid`. This uses
| ``pass_cell_ids=True`` internally. If ``True``, ``pass_cell_ids``
| will also be set to ``True``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the tetrahedral cells.
|
| Examples
| --------
| Divide a rectangular grid into tetrahedrons. Each cell contains by
| default 5 tetrahedrons.
|
| First, create and plot the grid.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 2)
| >>> yrng = np.linspace(0, 1, 2)
| >>> zrng = np.linspace(0, 2, 3)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> grid.plot()
|
| Now, generate the tetrahedra plot in the exploded view of the cell.
|
| >>> tet_grid = grid.to_tetrahedra()
| >>> tet_grid.explode(factor=0.5).plot(show_edges=True)
|
| Take the same grid but divide the first cell into 5 cells and the other
| cell into 12 tetrahedrons per cell.
|
| >>> tet_grid = grid.to_tetrahedra(mixed=[5, 12])
| >>> tet_grid.explode(factor=0.5).plot(show_edges=True)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkRectilinearGrid:
|
| ComputeBounds(...)
| ComputeBounds(self) -> None
| C++: void ComputeBounds() override;
|
| Compute the data bounding box from data points. THIS METHOD IS
| NOT THREAD SAFE.
|
| ComputeCellId(...)
| ComputeCellId(self, ijk:[int, int, int]) -> int
| C++: vtkIdType ComputeCellId(int ijk[3]) override;
|
| Given a location in structured coordinates (i-j-k), return the
| cell id. Rely on vtkStructuredData::ComputeCellId Unifying this
| behavior with vtkImageData could be considered.
|
| ComputePointId(...)
| ComputePointId(self, ijk:[int, int, int]) -> int
| C++: vtkIdType ComputePointId(int ijk[3]) override;
|
| Given a location in structured coordinates (i-j-k), return the
| point id. Rely on vtkStructuredData::ComputePointId Unifying this
| behavior with vtkImageData could be considered.
|
| ComputeStructuredCoordinates(...)
| ComputeStructuredCoordinates(self, x:(float, float, float),
| ijk:[int, int, int], pcoords:[float, float, float]) -> int
| C++: int ComputeStructuredCoordinates(const double x[3],
| int ijk[3], double pcoords[3]) override;
| ComputeStructuredCoordinates(self, x:[float, float, float],
| ijk:[int, int, int], pcoords:[float, float, float]) -> int
| C++: int ComputeStructuredCoordinates(double x[3], int ijk[3],
| double pcoords[3])
|
| Computes the structured coordinates for a point x[3]. The cell is
| specified by the array ijk[3], and the parametric coordinates in
| the cell are specified with pcoords[3]. The function returns a 0
| if the point x is outside of the grid, and a 1 if inside the
| grid.
|
| CopyStructure(...)
| CopyStructure(self, ds:vtkDataSet) -> None
| C++: void CopyStructure(vtkDataSet *ds) override;
|
| Copy the geometric and topological structure of an input
| rectilinear grid object.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: void Crop(const int *updateExtent) override;
|
| Reallocates and copies to set the Extent to the UpdateExtent.
| This is used internally when the exact extent is requested, and
| the source generated more than the update extent.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| ExtendedNew(...)
| ExtendedNew() -> vtkRectilinearGrid
| C++: static vtkRectilinearGrid *ExtendedNew()
|
| FindCell(...)
| FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int,
| tol2:float, subId:int, pcoords:[float, float, float],
| weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
| FindCell(self, x:[float, float, float], cell:vtkCell,
| gencell:vtkGenericCell, cellId:int, tol2:float, subId:int,
| pcoords:[float, float, float], weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkGenericCell *gencell, vtkIdType cellId, double tol2,
| int &subId, double pcoords[3], double *weights) override;
|
| Locate cell based on global coordinate x and tolerance squared.
| If cell and cellId is non-nullptr, then search starts from this
| cell and looks at immediate neighbors. Returns cellId >= 0 if
| inside, < 0 otherwise. The parametric coordinates are provided
| in pcoords[3]. The interpolation weights are returned in
| weights[]. (The number of weights is equal to the number of
| points in the found cell). Tolerance is used to control how close
| the point is to be considered "in" the cell. THIS METHOD IS NOT
| THREAD SAFE.
|
| FindPoint(...)
| FindPoint(self, x:[float, float, float]) -> int
| C++: vtkIdType FindPoint(double x[3]) override;
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated. The
| memory size returned is guaranteed to be greater than or equal to
| the memory required to represent the data (e.g., extra space in
| arrays, etc. are not included in the return value). THIS METHOD
| IS THREAD SAFE.
|
| GetCell(...)
| GetCell(self, cellId:int, cell:vtkGenericCell) -> None
| C++: void GetCell(vtkIdType cellId, vtkGenericCell *cell)
| override;
| GetCell(self, cellId:int) -> vtkCell
| C++: vtkCell *GetCell(vtkIdType cellId) override;
| GetCell(self, i:int, j:int, k:int) -> vtkCell
| C++: vtkCell *GetCell(int i, int j, int k) override;
|
| Standard vtkDataSet API methods. See vtkCartesianGrid for more
| information.
|
| GetCellBounds(...)
| GetCellBounds(self, cellId:int, bounds:[float, float, float,
| float, float, float]) -> None
| C++: void GetCellBounds(vtkIdType cellId, double bounds[6])
| override;
|
| Get the bounds of the cell with cellId such that: 0 <= cellId <
| NumberOfCells. A subclass may be able to determine the bounds of
| cell without using an expensive GetCell() method. A default
| implementation is provided that actually uses a GetCell() call.
| This is to ensure the method is available to all datasets.
| Subclasses should override this method to provide an efficient
| implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkRectilinearGrid
| C++: static vtkRectilinearGrid *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkRectilinearGrid
| C++: static vtkRectilinearGrid *GetData(vtkInformationVector *v,
| int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return what type of dataset this is.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetPoint(...)
| GetPoint(self, i:int, j:int, k:int, p:[float, float, float])
| -> None
| C++: void GetPoint(int i, int j, int k, double p[3])
| GetPoint(self, id:int, x:[float, float, float]) -> None
| C++: void GetPoint(vtkIdType id, double x[3]) override;
| GetPoint(self, ptId:int) -> (float, float, float)
| C++: double *GetPoint(vtkIdType ptId) override;
|
| Given the IJK-coordinates of the point, it returns the
| corresponding xyz-coordinates. The xyz coordinates are stored in
| the user-supplied array p.
|
| GetXCoordinates(...)
| GetXCoordinates(self) -> vtkDataArray
| C++: virtual vtkDataArray *GetXCoordinates()
|
| GetYCoordinates(...)
| GetYCoordinates(self) -> vtkDataArray
| C++: virtual vtkDataArray *GetYCoordinates()
|
| GetZCoordinates(...)
| GetZCoordinates(self) -> vtkDataArray
| C++: virtual vtkDataArray *GetZCoordinates()
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Restore object to initial state. Release memory back to system.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkRectilinearGrid
| C++: vtkRectilinearGrid *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkRectilinearGrid
| C++: static vtkRectilinearGrid *SafeDownCast(vtkObjectBase *o)
|
| SetXCoordinates(...)
| SetXCoordinates(self, __a:vtkDataArray) -> None
| C++: virtual void SetXCoordinates(vtkDataArray *)
|
| Specify the grid coordinates in the x-direction.
|
| SetYCoordinates(...)
| SetYCoordinates(self, __a:vtkDataArray) -> None
| C++: virtual void SetYCoordinates(vtkDataArray *)
|
| Specify the grid coordinates in the y-direction.
|
| SetZCoordinates(...)
| SetZCoordinates(self, __a:vtkDataArray) -> None
| C++: virtual void SetZCoordinates(vtkDataArray *)
|
| Specify the grid coordinates in the z-direction.
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkRectilinearGrid:
|
| __this__
| Pointer to the C++ object.
|
| data_object_type
| read-only, calls GetDataObjectType
|
| x_coordinates
| read-write, calls GetXCoordinates/SetXCoordinates
|
| y_coordinates
| read-write, calls GetYCoordinates/SetYCoordinates
|
| z_coordinates
| read-write, calls GetZCoordinates/SetZCoordinates
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkRectilinearGrid:
|
| __vtkname__ = 'vtkRectilinearGrid'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkCartesianGrid:
|
| BlankCell(...)
| BlankCell(self, ptId:int) -> None
| C++: virtual void BlankCell(vtkIdType ptId)
| BlankCell(self, i:int, j:int, k:int) -> None
| C++: virtual void BlankCell(int i, int j, int k)
|
| Methods for supporting blanking of cells. Blanking turns on or
| off cells in the structured grid. These methods should be called
| only after the dimensions of the grid are set.
|
| BlankPoint(...)
| BlankPoint(self, ptId:int) -> None
| C++: virtual void BlankPoint(vtkIdType ptId)
| BlankPoint(self, i:int, j:int, k:int) -> None
| C++: virtual void BlankPoint(int i, int j, int k)
|
| Methods for supporting blanking of cells. Blanking turns on or
| off points in the structured grid, and hence the cells connected
| to them. These methods should be called only after the dimensions
| of the grid are set.
|
| FindAndGetCell(...)
| FindAndGetCell(self, x:[float, float, float], cell:vtkCell,
| cellId:int, tol2:float, subId:int, pcoords:[float, float,
| float], weights:[float, ...]) -> vtkCell
| C++: vtkCell *FindAndGetCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
|
| Locate the cell that contains a point and return the cell. Also
| returns the subcell id, parametric coordinates and weights for
| subsequent interpolation. This method combines the derived class
| methods int FindCell and vtkCell *GetCell. Derived classes may
| provide a more efficient implementation. See for example
| vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE.
|
| GetCellDims(...)
| GetCellDims(self, cellDims:[int, int, int]) -> None
| C++: void GetCellDims(int cellDims[3])
|
| Given the node dimensions of this grid instance, this method
| computes the node dimensions. The value in each dimension can
| will have a lowest value of "1" such that computing the total
| number of cells can be achieved by simply by
| cellDims[0]*cellDims[1]*cellDims[2].
|
| GetCellNeighbors(...)
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds) override;
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList, seedLoc:[int, ...]) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds, int *seedLoc)
|
| Topological inquiry to get all cells using list of points
| exclusive of cell specified (e.g., cellId). Note that the list
| consists of only cells that use ALL the points provided. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetCellPoints(...)
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...),
| ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts, vtkIdList *ptIds) override;
| GetCellPoints(self, cellId:int, ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
| override;
|
| Topological inquiry to get points defining cell.
|
| This function MAY use ptIds, which is an object that is created
| by each thread, to guarantee thread safety.
|
| @warning Subsequent calls to this method may invalidate previous
| call
| results.
|
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetCellSize(...)
| GetCellSize(self, cellId:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType cellId) override;
|
| Get the size of cell with cellId such that: 0 <= cellId <
| NumberOfCells. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| @warning This method MUST be overridden for performance reasons.
| Default implementation is very inefficient.
|
| GetCellType(...)
| GetCellType(self, cellId:int) -> int
| C++: int GetCellType(vtkIdType cellId) override;
|
| Get type of cell with cellId such that: 0 <= cellId <
| NumberOfCells. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetCellTypes(...)
| GetCellTypes(self) -> vtkConstantArray_IhE
| C++: vtkConstantArray<unsigned char> *GetCellTypes()
| GetCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetCellTypes(vtkCellTypes *types)
|
| GetCellTypesArray(...)
| GetCellTypesArray(self) -> vtkConstantArray_IiE
| C++: vtkConstantArray<int> *GetCellTypesArray()
|
| GetCells(...)
| GetCells(self) -> vtkStructuredCellArray
| C++: vtkStructuredCellArray *GetCells()
|
| Return the image data connectivity array.
|
| NOTE: the returned object should not be modified.
|
| GetDataDescription(...)
| GetDataDescription(self) -> int
| C++: virtual int GetDataDescription()
|
| Get the data description of the rectilinear grid.
|
| GetDataDimension(...)
| GetDataDimension(self) -> int
| C++: int GetDataDimension()
|
| Return the dimensionality of the data.
|
| GetDimensions(...)
| GetDimensions(self) -> (int, int, int)
| C++: int *GetDimensions()
| GetDimensions(self, dims:[int, int, int]) -> None
| C++: void GetDimensions(int dims[3])
| GetDimensions(self, dims:[int, int, int]) -> None
| C++: void GetDimensions(vtkIdType dims[3])
|
| Get dimensions of this structured points dataset. It is the
| number of points on each axis. Dimensions are computed from
| Extents during this call.
| \warning Non thread-safe, use second signature if you want it to
| be.
|
| GetExtent(...)
| GetExtent(self) -> (int, int, int, int, int, int)
| C++: virtual int *GetExtent()
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: int GetExtentType() override;
|
| Structured extent. The extent type is a 3D extent
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Convenience method returns largest cell size in dataset. This is
| generally used to allocate memory for supporting data structures.
| THIS METHOD IS THREAD SAFE
|
| GetMaxSpatialDimension(...)
| GetMaxSpatialDimension(self) -> int
| C++: int GetMaxSpatialDimension() override;
|
| Get the maximum/minimum spatial dimensionality of the data which
| is the maximum/minimum dimension of all cells.
|
| @warning This method MUST be overridden for performance reasons.
| Default implementation is very inefficient.
|
| GetMinSpatialDimension(...)
| GetMinSpatialDimension(self) -> int
| C++: int GetMinSpatialDimension() override;
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| Determine the number of cells composing the dataset. THIS METHOD
| IS THREAD SAFE
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| Determine the number of points composing the dataset. THIS METHOD
| IS THREAD SAFE
|
| GetNumberOfScalarComponents(...)
| GetNumberOfScalarComponents(meta_data:vtkInformation) -> int
| C++: static int GetNumberOfScalarComponents(
| vtkInformation *meta_data)
| GetNumberOfScalarComponents(self) -> int
| C++: int GetNumberOfScalarComponents()
|
| GetPointCells(...)
| GetPointCells(self, ptId:int, cellIds:vtkIdList) -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
| override;
|
| Topological inquiry to get cells using point. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints() override;
|
| Standard vtkDataSet API methods. See vtkDataSet for more
| information.
|
| GetScalarType(...)
| GetScalarType(meta_data:vtkInformation) -> int
| C++: static int GetScalarType(vtkInformation *meta_data)
| GetScalarType(self) -> int
| C++: int GetScalarType()
|
| GetScalarTypeAsString(...)
| GetScalarTypeAsString(self) -> str
| C++: const char *GetScalarTypeAsString()
|
| GetTupleIndex(...)
| GetTupleIndex(self, array:vtkDataArray, coordinates:[int, int,
| int]) -> int
| C++: vtkIdType GetTupleIndex(vtkDataArray *array,
| int coordinates[3])
| GetTupleIndex(self, array:vtkDataArray, x:int, y:int, z:int)
| -> int
| C++: vtkIdType GetTupleIndex(vtkDataArray *array, int x, int y,
| int z)
|
| GetTupleIndexForExtent(...)
| GetTupleIndexForExtent(self, array:vtkDataArray, extent:[int, int,
| int, int, int, int]) -> int
| C++: vtkIdType GetTupleIndexForExtent(vtkDataArray *array,
| int extent[6])
|
| Given a data array and a coordinate, return the index of the
| tuple in the array corresponding to that coordinate.
|
| GetValueIndex(...)
| GetValueIndex(self, array:vtkDataArray, coordinates:[int, int,
| int]) -> int
| C++: vtkIdType GetValueIndex(vtkDataArray *array,
| int coordinates[3])
| GetValueIndex(self, array:vtkDataArray, x:int, y:int, z:int)
| -> int
| C++: vtkIdType GetValueIndex(vtkDataArray *array, int x, int y,
| int z)
|
| GetValueIndexForExtent(...)
| GetValueIndexForExtent(self, array:vtkDataArray, extent:[int, int,
| int, int, int, int]) -> int
| C++: vtkIdType GetValueIndexForExtent(vtkDataArray *array,
| int extent[6])
|
| Given a data array and a coordinate, return the index of the
| value in the array corresponding to that coordinate, considering
| the number of components.
|
| HasAnyBlankCells(...)
| HasAnyBlankCells(self) -> bool
| C++: bool HasAnyBlankCells() override;
|
| Returns 1 if there are any blanking cells 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyBlankPoints(...)
| HasAnyBlankPoints(self) -> bool
| C++: bool HasAnyBlankPoints() override;
|
| Returns 1 if there are any blanking points 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasNumberOfScalarComponents(...)
| HasNumberOfScalarComponents(meta_data:vtkInformation) -> bool
| C++: static bool HasNumberOfScalarComponents(
| vtkInformation *meta_data)
|
| HasScalarType(...)
| HasScalarType(meta_data:vtkInformation) -> bool
| C++: static bool HasScalarType(vtkInformation *meta_data)
|
| IsCellVisible(...)
| IsCellVisible(self, cellId:int) -> int
| C++: unsigned char IsCellVisible(vtkIdType cellId)
|
| Return non-zero value if specified point is visible. These
| methods should be called only after the dimensions of the grid
| are set.
|
| IsPointVisible(...)
| IsPointVisible(self, ptId:int) -> int
| C++: unsigned char IsPointVisible(vtkIdType ptId)
|
| Return non-zero value if specified point is visible. These
| methods should be called only after the dimensions of the grid
| are set.
|
| SetDimensions(...)
| SetDimensions(self, i:int, j:int, k:int) -> None
| C++: void SetDimensions(int i, int j, int k)
| SetDimensions(self, dim:(int, int, int)) -> None
| C++: void SetDimensions(const int dim[3])
|
| Set dimensions of rectilinear grid dataset. This also sets the
| extent.
|
| SetExtent(...)
| SetExtent(self, extent:[int, int, int, int, int, int]) -> None
| C++: void SetExtent(int extent[6])
| SetExtent(self, xMin:int, xMax:int, yMin:int, yMax:int, zMin:int,
| zMax:int) -> None
| C++: void SetExtent(int xMin, int xMax, int yMin, int yMax,
| int zMin, int zMax)
|
| Set/Get the extent. On each axis, the extent is defined by the
| index of the first point and the index of the last point. The
| extent should be set before the "Scalars" are set or allocated.
| The Extent is stored in the order (X, Y, Z). The dataset extent
| does not have to start at (0,0,0). (0,0,0) is just the extent of
| the origin. The first point (the one with Id=0) is at extent
| (Extent[0],Extent[2],Extent[4]). As for any dataset, a data array
| on point data starts at Id=0.
|
| SetNumberOfScalarComponents(...)
| SetNumberOfScalarComponents(n:int, meta_data:vtkInformation)
| -> None
| C++: static void SetNumberOfScalarComponents(int n,
| vtkInformation *meta_data)
|
| Set/Get the number of scalar components for points. As with the
| SetScalarType method this is setting pipeline info. 1 if not set
| or empty.
|
| SetScalarType(...)
| SetScalarType(__a:int, meta_data:vtkInformation) -> None
| C++: static void SetScalarType(int, vtkInformation *meta_data)
|
| Set/Get the scalar data type for the points. This is setting
| pipeline info. Assume VTK_DOUBLE if not set or empty.
|
| UnBlankCell(...)
| UnBlankCell(self, ptId:int) -> None
| C++: virtual void UnBlankCell(vtkIdType ptId)
| UnBlankCell(self, i:int, j:int, k:int) -> None
| C++: virtual void UnBlankCell(int i, int j, int k)
|
| UnBlankPoint(...)
| UnBlankPoint(self, ptId:int) -> None
| C++: virtual void UnBlankPoint(vtkIdType ptId)
| UnBlankPoint(self, i:int, j:int, k:int) -> None
| C++: virtual void UnBlankPoint(int i, int j, int k)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkCartesianGrid:
|
| cell_types
| read-only, calls GetCellTypes
|
| cell_types_array
| read-only, calls GetCellTypesArray
|
| cells
| read-only, calls GetCells
|
| data_description
| read-only, calls GetDataDescription
|
| data_dimension
| read-only, calls GetDataDimension
|
| extent
| read-write, calls GetExtent/SetExtent
|
| extent_type
| read-only, calls GetExtentType
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| max_spatial_dimension
| read-only, calls GetMaxSpatialDimension
|
| min_spatial_dimension
| read-only, calls GetMinSpatialDimension
|
| number_of_scalar_components
| read-only, calls GetNumberOfScalarComponents
|
| scalar_type
| read-only, calls GetScalarType
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| AllocateCellGhostArray(...)
| AllocateCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocateCellGhostArray()
|
| Allocate ghost array for cells.
|
| AllocatePointGhostArray(...)
| AllocatePointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocatePointGhostArray()
|
| Allocate ghost array for points.
|
| CheckAttributes(...)
| CheckAttributes(self) -> int
| C++: int CheckAttributes()
|
| This method checks to see if the cell and point attributes match
| the geometry. Many filters will crash if the number of tuples in
| an array is less than the number of points/cells. This method
| returns 1 if there is a mismatch, and 0 if everything is ok. It
| prints an error if an array is too short, and a warning if an
| array is too long.
|
| CopyAttributes(...)
| CopyAttributes(self, ds:vtkDataSet) -> None
| C++: virtual void CopyAttributes(vtkDataSet *ds)
|
| Copy the attributes associated with the specified dataset to this
| instance of vtkDataSet. THIS METHOD IS NOT THREAD SAFE.
|
| GenerateGhostArray(...)
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int])
| -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6])
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int],
| cellOnly:bool) -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6],
| bool cellOnly)
|
| Normally called by pipeline executives or algorithms only. This
| method computes the ghost arrays for a given dataset. The zeroExt
| argument specifies the extent of the region which ghost type = 0.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return a pointer to the geometry bounding box in the form
| (xmin,xmax, ymin,ymax, zmin,zmax). THIS METHOD IS NOT THREAD
| SAFE.
|
| GetCellData(...)
| GetCellData(self) -> vtkCellData
| C++: vtkCellData *GetCellData()
|
| Return a pointer to this dataset's cell data. THIS METHOD IS
| THREAD SAFE
|
| GetCellGhostArray(...)
| GetCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellGhostArray()
|
| Get the array that defines the ghost type of each cell. We cache
| the pointer to the array to save a lookup involving string
| comparisons
|
| GetCellNumberOfFaces(...)
| GetCellNumberOfFaces(self, cellId:int, cellType:int,
| cell:vtkGenericCell) -> int
| C++: virtual int GetCellNumberOfFaces(vtkIdType cellId,
| unsigned char &cellType, vtkGenericCell *cell)
|
| Get the number of faces of a cell.
|
| Most of the times extracting the number of faces requires only
| extracting the cell type. However, for some cell types, the
| number of faces is not constant. For example, a convex point set
| cell can have a different number of faces for each cell. That's
| why this method requires the cell id and the dataset.
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: double *GetCenter()
| GetCenter(self, center:[float, float, float]) -> None
| C++: void GetCenter(double center[3])
|
| Get the center of the bounding box. THIS METHOD IS NOT THREAD
| SAFE.
|
| GetDistinctCellTypes(...)
| GetDistinctCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetDistinctCellTypes(vtkCellTypes *types)
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset 5 triangles, 3 lines, and
| 100 hexahedra would result a list of three entries, corresponding
| to the types VTK_TRIANGLE, VTK_LINE, and VTK_HEXAHEDRON. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetGhostArray(int type) override;
|
| Returns the ghost array for the given type (point or cell). Takes
| advantage of the cache with the pointer to the array to save a
| string comparison.
|
| GetLength(...)
| GetLength(self) -> float
| C++: double GetLength()
|
| Return the length of the diagonal of the bounding box. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Return the squared length of the diagonal of the bounding box.
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Datasets are composite objects and need to check each part for
| MTime THIS METHOD IS THREAD SAFE
|
| GetMeshMTime(...)
| GetMeshMTime(self) -> int
| C++: virtual vtkMTimeType GetMeshMTime()
|
| Abstract method which return the mesh (geometry/topology)
| modification time. This time is different from the usual MTime
| which also takes into account the modification of data arrays.
| This function can be used to track the changes on the mesh
| separately from the data arrays (eg. static mesh over time with
| transient data). The default implementation returns the MTime. It
| is up to subclasses to provide a better approach.
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| GetPointData(...)
| GetPointData(self) -> vtkPointData
| C++: vtkPointData *GetPointData()
|
| Return a pointer to this dataset's point data. THIS METHOD IS
| THREAD SAFE
|
| GetPointGhostArray(...)
| GetPointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetPointGhostArray()
|
| Gets the array that defines the ghost type of each point. We
| cache the pointer to the array to save a lookup involving string
| comparisons
|
| GetScalarRange(...)
| GetScalarRange(self, range:[float, float]) -> None
| C++: virtual void GetScalarRange(double range[2])
| GetScalarRange(self) -> (float, float)
| C++: double *GetScalarRange()
|
| Convenience method to get the range of the first component (and
| only the first component) of any scalars in the data set. If the
| data has both point data and cell data, it returns the (min/max)
| range of combined point and cell data. If there are no point or
| cell scalars the method will return (0,1). Note: It might be
| necessary to call Update to create or refresh the scalars before
| calling this method. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| HasAnyGhostCells(...)
| HasAnyGhostCells(self) -> bool
| C++: bool HasAnyGhostCells()
|
| Returns 1 if there are any ghost cells 0 otherwise.
|
| HasAnyGhostPoints(...)
| HasAnyGhostPoints(self) -> bool
| C++: bool HasAnyGhostPoints()
|
| Returns 1 if there are any ghost points 0 otherwise.
|
| NewCellIterator(...)
| NewCellIterator(self) -> vtkCellIterator
| C++: virtual vtkCellIterator *NewCellIterator()
|
| Return an iterator that traverses the cells in this data set.
|
| SetCellOrderAndRationalWeights(...)
| SetCellOrderAndRationalWeights(self, cellId:int,
| cell:vtkGenericCell) -> None
| C++: void SetCellOrderAndRationalWeights(vtkIdType cellId,
| vtkGenericCell *cell)
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: virtual void Squeeze()
|
| Reclaim any extra memory used to store data. THIS METHOD IS NOT
| THREAD SAFE.
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| cell_ghost_array
| read-only, calls GetCellGhostArray
|
| length2
| read-only, calls GetLength2
|
| m_time
| read-only, calls GetMTime
|
| mesh_m_time
| read-only, calls GetMeshMTime
|
| point_ghost_array
| read-only, calls GetPointGhostArray
|
| scalar_range
| read-only, calls GetScalarRange
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| CELL_DATA_FIELD = 2
|
| DATA_OBJECT_FIELD = 0
|
| FieldDataType = <class 'vtkmodules.vtkCommonDataModel.vtkDataSet.Field...
|
| POINT_DATA_FIELD = 1
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.RectilinearGridWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.Report
Python Library Documentation: function Report in module pyvista.report
Report(additional: 'list[str | ModuleType] | None' = None, ncol: 'int' = 3, text_width: 'int' = 80, sort: 'bool' = False, gpu: 'bool' = True, downloads: 'bool' = False)
Generate a PyVista software environment report.
.. versionadded:: 0.47
The report can now be generated using the shell command:
.. code-block:: shell
pyvista report --sort ...
Run ``pyvista report --help`` for more details on available parameters.
Parameters
----------
additional : sequence[types.ModuleType], sequence[str]
List of packages or package names to add to output information.
ncol : int, default: 3
Number of package-columns in html table; only has effect if
``mode='HTML'`` or ``mode='html'``.
text_width : int, default: 80
The text width for non-HTML display modes.
sort : bool, default: False
Alphabetically sort the packages.
gpu : bool, default: True
Gather information about the GPU. Defaults to ``True`` but if
experiencing rendering issues, pass ``False`` to safely generate a
report.
downloads : bool, default: False
Gather information about downloads. If ``True``, includes:
- The local user data path (where downloads are saved)
- The VTK Data source (where files are downloaded from)
- Whether local file caching is enabled for the VTK Data source
.. versionadded:: 0.47
Examples
--------
>>> import pyvista as pv
>>> pv.Report() # doctest:+SKIP
Date: Fri Oct 28 15:54:11 2022 MDT
<BLANKLINE>
OS : Linux
CPU(s) : 6
Machine : x86_64
Architecture : 64bit
RAM : 62.6 GiB
Environment : IPython
File system : ext4
GPU Vendor : NVIDIA Corporation
GPU Renderer : Quadro P2000/PCIe/SSE2
GPU Version : 4.5.0 NVIDIA 470.141.03
<BLANKLINE>
Python 3.8.10 (default, Jun 22 2022, 20:18:18) [GCC 9.4.0]
<BLANKLINE>
pyvista : 0.37.dev0
vtk : 9.1.0
numpy : 1.23.3
imageio : 2.22.0
scooby : 0.7.1.dev1+gf097dad
pooch : v1.6.0
matplotlib : 3.6.0
IPython : 7.31.0
colorcet : 3.0.1
cmocean : 2.0
scipy : 1.9.1
tqdm : 4.64.1
meshio : 5.3.4
jupyterlab : 3.4.7
pyvista.RotationLike
Python Library Documentation: _UnionGenericAlias in module typing
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
pyvista.SLCReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.STLReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.STLWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.SegYReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.SeriesDataSet
Python Library Documentation: class SeriesDataSet in module pyvista.core.utilities.reader
class SeriesDataSet(pyvista.core.utilities.misc._NoNewAttrMixin)
| SeriesDataSet(*args, **kwargs) -> '_T'
|
| Class for storing dataset info from series file.
|
| Method resolution order:
| SeriesDataSet
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, name: 'str', time: 'float') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __repr__(self)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'name': 'str', 'time': 'float'}
|
| __dataclass_fields__ = {'name': Field(name='name',type='str',default=<...
|
| __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
|
| __hash__ = None
|
| __match_args__ = ('name', 'time')
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
pyvista.SeriesReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.SimplePointsWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.SolidSphere
Python Library Documentation: function SolidSphere in module pyvista.core.utilities.geometric_objects
SolidSphere(outer_radius: 'float' = 0.5, inner_radius: 'float' = 0.0, radius_resolution: 'int' = 5, start_theta: 'float' = 0.0, end_theta: 'float | None' = None, theta_resolution: 'int' = 30, start_phi: 'float' = 0.0, end_phi: 'float | None' = None, phi_resolution: 'int' = 30, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (0.0, 0.0, 1.0), radians: 'bool' = False, tol_radius: 'float' = 1e-08, tol_angle: 'float | None' = None) -> 'UnstructuredGrid'
Create a solid sphere.
A solid sphere fills space in 3D in comparison to
:func:`pyvista.Sphere`, which is a 2D surface.
This function uses a linear sampling of each spherical
coordinate, whereas :func:`pyvista.SolidSphereGeneric`
allows for nonuniform sampling. Angles are by default
specified in degrees.
PyVista uses a convention where ``theta`` represents the azimuthal
angle (similar to degrees longitude on the globe) and ``phi``
represents the polar angle (similar to degrees latitude on the
globe). In contrast to latitude on the globe, here
``phi`` is 0 degrees at the North Pole and 180 degrees at the South
Pole. ``phi=0`` is on the positive z-axis by default.
``theta=0`` is on the positive x-axis by default.
While values for theta can be any value with a maximum span of
360 degrees, large magnitudes may result in problems with endpoint
overlap detection.
Parameters
----------
outer_radius : float, default: 0.5
Outer radius of sphere. Must be non-negative.
inner_radius : float, default: 0.0
Inner radius of sphere. Must be non-negative
and smaller than ``outer_radius``.
radius_resolution : int, default: 5
Number of points in radial direction.
start_theta : float, default: 0.0
Starting azimuthal angle.
end_theta : float, default: 360.0
Ending azimuthal angle.
``end_theta`` must be greater than ``start_theta``.
theta_resolution : int, default: 30
Number of points in ``theta`` direction.
start_phi : float, default: 0.0
Starting polar angle.
``phi`` must lie between 0 and 180 in degrees.
end_phi : float, default: 180.0
Ending polar angle.
``phi`` must lie between 0 and 180 in degrees.
``end_phi`` must be greater than ``start_phi``.
phi_resolution : int, default: 30
Number of points in ``phi`` direction,
inclusive of polar axis, i.e. ``phi=0`` and ``phi=180``
in degrees, if applicable.
center : sequence[float], default: (0.0, 0.0, 0.0)
Center coordinate vector in ``[x, y, z]``.
direction : sequence[float], default: (0.0, 0.0, 1.0)
Direction coordinate vector in ``[x, y, z]`` pointing from ``center`` to
the sphere's north pole at zero degrees ``phi``.
radians : bool, default: False
Whether to use radians for ``theta`` and ``phi``. Default is degrees.
tol_radius : float, default: 1.0e-8
Absolute tolerance for endpoint detection for ``radius``.
tol_angle : float, optional
Absolute tolerance for endpoint detection
for ``phi`` and ``theta``. Unit is determined by choice
of ``radians`` parameter. Default is 1.0e-8 degrees or
1.0e-8 degrees converted to radians.
Returns
-------
pyvista.UnstructuredGrid
Solid sphere mesh.
See Also
--------
pyvista.Sphere: Sphere that describes outer 2D surface.
pyvista.SolidSphereGeneric: Uses more flexible parameter definition.
Examples
--------
Create a solid sphere.
>>> import pyvista as pv
>>> import numpy as np
>>> solid_sphere = pv.SolidSphere()
>>> solid_sphere.plot(show_edges=True)
A solid sphere is 3D in comparison to the 2d :func:`pyvista.Sphere`.
Generate a solid hemisphere to see the internal structure.
>>> isinstance(solid_sphere, pv.UnstructuredGrid)
True
>>> partial_solid_sphere = pv.SolidSphere(start_theta=180, end_theta=360)
>>> partial_solid_sphere.plot(show_edges=True)
To see the cell structure inside the solid sphere,
only 1/4 of the sphere is generated. The cells are exploded
and colored by radial position.
>>> partial_solid_sphere = pv.SolidSphere(
... start_theta=180,
... end_theta=360,
... start_phi=0,
... end_phi=90,
... radius_resolution=5,
... theta_resolution=8,
... phi_resolution=8,
... )
>>> partial_solid_sphere['cell_radial_pos'] = np.linalg.norm(
... partial_solid_sphere.cell_centers().points, axis=-1
... )
>>> partial_solid_sphere.explode(1).plot()
pyvista.SolidSphereGeneric
Python Library Documentation: function SolidSphereGeneric in module pyvista.core.utilities.geometric_objects
SolidSphereGeneric(radius: 'VectorLike[float] | None' = None, theta: 'VectorLike[float] | None' = None, phi: 'VectorLike[float] | None' = None, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (0.0, 0.0, 1.0), radians: 'bool' = False, tol_radius: 'float' = 1e-08, tol_angle: 'float | None' = None) -> 'UnstructuredGrid'
Create a solid sphere with flexible sampling.
A solid sphere fills space in 3D in comparison to
:func:`pyvista.Sphere`, which is a 2D surface.
This function allows user defined sampling of each spherical
coordinate, whereas :func:`pyvista.SolidSphere`
only allows linear sampling. Angles are by default
specified in degrees.
PyVista uses a convention where ``theta`` represents the azimuthal
angle (similar to degrees longitude on the globe) and ``phi``
represents the polar angle (similar to degrees latitude on the
globe). In contrast to latitude on the globe, here
``phi`` is 0 degrees at the North Pole and 180 degrees at the South
Pole. ``phi=0`` is on the positive z-axis by default.
``theta=0`` is on the positive x-axis by default.
Parameters
----------
radius : sequence[float], optional
A monotonically increasing sequence of values specifying radial
points. Must have at least two points and be non-negative.
theta : sequence[float], optional
A monotonically increasing sequence of values specifying ``theta``
points. Must have at least two points. Can have any value as long
as range is within 360 degrees. Large magnitudes may result in
problems with endpoint overlap detection.
phi : sequence[float], optional
A monotonically increasing sequence of values specifying ``phi``
points. Must have at least two points. Must be between
0 and 180 degrees.
center : sequence[float], default: (0.0, 0.0, 0.0)
Center coordinate vector in ``[x, y, z]``.
direction : sequence[float], default: (0.0, 0.0, 1.0)
Direction coordinate vector in ``[x, y, z]`` pointing from ``center`` to
the sphere's north pole at zero degrees ``phi``.
radians : bool, default: False
Whether to use radians for ``theta`` and ``phi``. Default is degrees.
tol_radius : float, default: 1.0e-8
Absolute tolerance for endpoint detection for ``radius``.
tol_angle : float, optional
Absolute tolerance for endpoint detection
for ``phi`` and ``theta``. Unit is determined by choice
of ``radians`` parameter. Default is 1.0e-8 degrees or
1.0e-8 degrees converted to radians.
Returns
-------
pyvista.UnstructuredGrid
Solid sphere mesh.
See Also
--------
pyvista.SolidSphere: Sphere creation using linear sampling.
pyvista.Sphere: Sphere that describes outer 2D surface.
Examples
--------
Linearly sampling spherical coordinates does not lead to
cells of all the same size at each radial position.
Cells near the poles have smaller sizes.
>>> import pyvista as pv
>>> import numpy as np
>>> solid_sphere = pv.SolidSphereGeneric(
... radius=np.linspace(0, 0.5, 2),
... theta=np.linspace(180, 360, 30),
... phi=np.linspace(0, 180, 30),
... )
>>> solid_sphere = solid_sphere.compute_cell_sizes()
>>> solid_sphere.plot(scalars='Volume', show_edges=True, clim=[3e-5, 5e-4])
Sampling the polar angle in a nonlinear manner allows for consistent cell volumes. See
`Sphere Point Picking <https://mathworld.wolfram.com/SpherePointPicking.html>`_.
>>> phi = np.rad2deg(np.arccos(np.linspace(1, -1, 30)))
>>> solid_sphere = pv.SolidSphereGeneric(
... radius=np.linspace(0, 0.5, 2),
... theta=np.linspace(180, 360, 30),
... phi=phi,
... )
>>> solid_sphere = solid_sphere.compute_cell_sizes()
>>> solid_sphere.plot(scalars='Volume', show_edges=True, clim=[3e-5, 5e-4])
pyvista.Sphere
Python Library Documentation: function Sphere in module pyvista.core.utilities.geometric_objects
Sphere(radius: 'float' = 0.5, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (0.0, 0.0, 1.0), theta_resolution: 'int' = 30, phi_resolution: 'int' = 30, start_theta: 'float' = 0.0, end_theta: 'float' = 360.0, start_phi: 'float' = 0.0, end_phi: 'float' = 180.0) -> 'PolyData'
Create a sphere.
A sphere describes a 2D surface in comparison to
:func:`pyvista.SolidSphere`, which fills a 3D volume.
PyVista uses a convention where ``theta`` represents the azimuthal
angle (similar to degrees longitude on the globe) and ``phi``
represents the polar angle (similar to degrees latitude on the
globe). In contrast to latitude on the globe, here
``phi`` is 0 degrees at the North Pole and 180 degrees at the South
Pole. ``phi=0`` is on the positive z-axis by default.
``theta=0`` is on the positive x-axis by default.
See :ref:`create_sphere_example` for examples on creating spheres in
other ways.
Parameters
----------
radius : float, default: 0.5
Sphere radius.
center : sequence[float], default: (0.0, 0.0, 0.0)
Center coordinate vector in ``[x, y, z]``.
direction : sequence[float], default: (0.0, 0.0, 1.0)
Direction coordinate vector in ``[x, y, z]`` pointing from ``center`` to
the sphere's north pole at zero degrees ``phi``.
theta_resolution : int, default: 30
Set the number of points in the azimuthal direction (ranging
from ``start_theta`` to ``end_theta``).
phi_resolution : int, default: 30
Set the number of points in the polar direction (ranging from
``start_phi`` to ``end_phi``).
start_theta : float, default: 0.0
Starting azimuthal angle in degrees ``[0, 360]``.
end_theta : float, default: 360.0
Ending azimuthal angle in degrees ``[0, 360]``.
start_phi : float, default: 0.0
Starting polar angle in degrees ``[0, 180]``.
end_phi : float, default: 180.0
Ending polar angle in degrees ``[0, 180]``.
Returns
-------
pyvista.PolyData
Sphere mesh.
See Also
--------
pyvista.Icosphere : Sphere created from projection of icosahedron.
pyvista.SolidSphere : Sphere that fills 3D space.
:ref:`sphere_eversion_example` : Example turning a sphere inside-out.
Examples
--------
Create a sphere using default parameters.
>>> import pyvista as pv
>>> sphere = pv.Sphere()
>>> sphere.plot(show_edges=True)
Create a quarter sphere by setting ``end_theta``.
>>> sphere = pv.Sphere(end_theta=90)
>>> out = sphere.plot(show_edges=True)
Create a hemisphere by setting ``end_phi``.
>>> sphere = pv.Sphere(end_phi=90)
>>> out = sphere.plot(show_edges=True)
pyvista.SphereSource
Python Library Documentation: class SphereSource in module pyvista.core.utilities.geometric_sources
class SphereSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkSphereSource)
| SphereSource(*args, **kwargs) -> '_T'
|
| Sphere source algorithm class.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| radius : float, default: 0.5
| Sphere radius.
|
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Center coordinate vector in ``[x, y, z]``.
|
| theta_resolution : int, default: 30
| Set the number of points in the azimuthal direction (ranging
| from ``start_theta`` to ``end_theta``).
|
| phi_resolution : int, default: 30
| Set the number of points in the polar direction (ranging from
| ``start_phi`` to ``end_phi``).
|
| start_theta : float, default: 0.0
| Starting azimuthal angle in degrees ``[0, 360]``.
|
| end_theta : float, default: 360.0
| Ending azimuthal angle in degrees ``[0, 360]``.
|
| start_phi : float, default: 0.0
| Starting polar angle in degrees ``[0, 180]``.
|
| end_phi : float, default: 180.0
| Ending polar angle in degrees ``[0, 180]``.
|
| See Also
| --------
| pyvista.Icosphere : Sphere created from projection of icosahedron.
| pyvista.SolidSphere : Sphere that fills 3D space.
|
| Examples
| --------
| Create a sphere using default parameters.
|
| >>> import pyvista as pv
| >>> sphere = pv.SphereSource()
| >>> sphere.output.plot(show_edges=True)
|
| Create a quarter sphere by setting ``end_theta``.
|
| >>> sphere = pv.SphereSource(end_theta=90)
| >>> out = sphere.output.plot(show_edges=True)
|
| Create a hemisphere by setting ``end_phi``.
|
| >>> sphere = pv.SphereSource(end_phi=90)
| >>> out = sphere.output.plot(show_edges=True)
|
| Method resolution order:
| SphereSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkSphereSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'SphereSource', radius: 'float' = 0.5, center: 'VectorLike[float] | None' = None, theta_resolution: 'int' = 30, phi_resolution: 'int' = 30, start_theta: 'float' = 0.0, end_theta: 'float' = 360.0, start_phi: 'float' = 0.0, end_phi: 'float' = 180.0) -> 'None'
| Initialize the sphere source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Sphere surface.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Get the center in ``[x, y, z]``.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``.
|
| end_phi
| Get ending polar angle in degrees ``[0, 360]``.
|
| Returns
| -------
| float
| The number of points in the polar direction.
|
| end_theta
| Get ending azimuthal angle in degrees ``[0, 360]``.
|
| Returns
| -------
| float
| The number of points in the azimuthal direction.
|
| phi_resolution
| Get the number of points in the polar direction.
|
| Returns
| -------
| int
| The number of points in the polar direction.
|
| radius
| Get sphere radius.
|
| Returns
| -------
| float
| Sphere radius.
|
| start_phi
| Get starting polar angle in degrees ``[0, 360]``.
|
| Returns
| -------
| float
| The number of points in the polar direction.
|
| start_theta
| Get starting azimuthal angle in degrees ``[0, 360]``.
|
| Returns
| -------
| float
| The number of points in the azimuthal direction.
|
| theta_resolution
| Get the number of points in the azimuthal direction.
|
| Returns
| -------
| int
| The number of points in the azimuthal direction.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkSphereSource:
|
| GenerateNormalsOff(...)
| GenerateNormalsOff(self) -> None
| C++: virtual void GenerateNormalsOff()
|
| GenerateNormalsOn(...)
| GenerateNormalsOn(self) -> None
| C++: virtual void GenerateNormalsOn()
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetEndPhi(...)
| GetEndPhi(self) -> float
| C++: virtual double GetEndPhi()
|
| GetEndPhiMaxValue(...)
| GetEndPhiMaxValue(self) -> float
| C++: virtual double GetEndPhiMaxValue()
|
| GetEndPhiMinValue(...)
| GetEndPhiMinValue(self) -> float
| C++: virtual double GetEndPhiMinValue()
|
| GetEndTheta(...)
| GetEndTheta(self) -> float
| C++: virtual double GetEndTheta()
|
| GetEndThetaMaxValue(...)
| GetEndThetaMaxValue(self) -> float
| C++: virtual double GetEndThetaMaxValue()
|
| GetEndThetaMinValue(...)
| GetEndThetaMinValue(self) -> float
| C++: virtual double GetEndThetaMinValue()
|
| GetGenerateNormals(...)
| GetGenerateNormals(self) -> int
| C++: virtual vtkTypeBool GetGenerateNormals()
|
| GetLatLongTessellation(...)
| GetLatLongTessellation(self) -> int
| C++: virtual vtkTypeBool GetLatLongTessellation()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetPhiResolution(...)
| GetPhiResolution(self) -> int
| C++: virtual int GetPhiResolution()
|
| GetPhiResolutionMaxValue(...)
| GetPhiResolutionMaxValue(self) -> int
| C++: virtual int GetPhiResolutionMaxValue()
|
| GetPhiResolutionMinValue(...)
| GetPhiResolutionMinValue(self) -> int
| C++: virtual int GetPhiResolutionMinValue()
|
| GetRadius(...)
| GetRadius(self) -> float
| C++: virtual double GetRadius()
|
| GetRadiusMaxValue(...)
| GetRadiusMaxValue(self) -> float
| C++: virtual double GetRadiusMaxValue()
|
| GetRadiusMinValue(...)
| GetRadiusMinValue(self) -> float
| C++: virtual double GetRadiusMinValue()
|
| GetStartPhi(...)
| GetStartPhi(self) -> float
| C++: virtual double GetStartPhi()
|
| GetStartPhiMaxValue(...)
| GetStartPhiMaxValue(self) -> float
| C++: virtual double GetStartPhiMaxValue()
|
| GetStartPhiMinValue(...)
| GetStartPhiMinValue(self) -> float
| C++: virtual double GetStartPhiMinValue()
|
| GetStartTheta(...)
| GetStartTheta(self) -> float
| C++: virtual double GetStartTheta()
|
| GetStartThetaMaxValue(...)
| GetStartThetaMaxValue(self) -> float
| C++: virtual double GetStartThetaMaxValue()
|
| GetStartThetaMinValue(...)
| GetStartThetaMinValue(self) -> float
| C++: virtual double GetStartThetaMinValue()
|
| GetThetaResolution(...)
| GetThetaResolution(self) -> int
| C++: virtual int GetThetaResolution()
|
| GetThetaResolutionMaxValue(...)
| GetThetaResolutionMaxValue(self) -> int
| C++: virtual int GetThetaResolutionMaxValue()
|
| GetThetaResolutionMinValue(...)
| GetThetaResolutionMinValue(self) -> int
| C++: virtual int GetThetaResolutionMinValue()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| LatLongTessellationOff(...)
| LatLongTessellationOff(self) -> None
| C++: virtual void LatLongTessellationOff()
|
| LatLongTessellationOn(...)
| LatLongTessellationOn(self) -> None
| C++: virtual void LatLongTessellationOn()
|
| NewInstance(...)
| NewInstance(self) -> vtkSphereSource
| C++: vtkSphereSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkSphereSource
| C++: static vtkSphereSource *SafeDownCast(vtkObjectBase *o)
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set the center of the sphere. Default is (0,0,0).
|
| SetEndPhi(...)
| SetEndPhi(self, _arg:float) -> None
| C++: virtual void SetEndPhi(double _arg)
|
| Set the ending latitude angle. By default EndPhi=180 degrees.
|
| SetEndTheta(...)
| SetEndTheta(self, _arg:float) -> None
| C++: virtual void SetEndTheta(double _arg)
|
| Set the ending longitude angle. By default EndTheta=360 degrees.
|
| SetGenerateNormals(...)
| SetGenerateNormals(self, _arg:int) -> None
| C++: virtual void SetGenerateNormals(vtkTypeBool _arg)
|
| Specify whether to generate output point normals. By default this
| is enabled.
|
| SetLatLongTessellation(...)
| SetLatLongTessellation(self, _arg:int) -> None
| C++: virtual void SetLatLongTessellation(vtkTypeBool _arg)
|
| Cause the sphere to be tessellated with edges along the latitude
| and longitude lines. If off, triangles are generated at non-polar
| regions, which results in edges that are not parallel to latitude
| and longitude lines. If on, quadrilaterals are generated
| everywhere except at the poles. This can be useful for generating
| a wireframe sphere with natural latitude and longitude lines.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetPhiResolution(...)
| SetPhiResolution(self, _arg:int) -> None
| C++: virtual void SetPhiResolution(int _arg)
|
| Set the number of points in the latitude direction (ranging from
| StartPhi to EndPhi).
|
| SetRadius(...)
| SetRadius(self, _arg:float) -> None
| C++: virtual void SetRadius(double _arg)
|
| Set the radius of sphere. Default is 0.5.
|
| SetStartPhi(...)
| SetStartPhi(self, _arg:float) -> None
| C++: virtual void SetStartPhi(double _arg)
|
| Set the starting latitude angle (0 is at north pole). By default
| StartPhi=0 degrees.
|
| SetStartTheta(...)
| SetStartTheta(self, _arg:float) -> None
| C++: virtual void SetStartTheta(double _arg)
|
| Set the starting longitude angle. By default StartTheta=0
| degrees.
|
| SetThetaResolution(...)
| SetThetaResolution(self, _arg:int) -> None
| C++: virtual void SetThetaResolution(int _arg)
|
| Set the number of points in the longitude direction (ranging from
| StartTheta to EndTheta).
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkSphereSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkSphereSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkSphereSource:
|
| __this__
| Pointer to the C++ object.
|
| generate_normals
| read-write, calls GetGenerateNormals/SetGenerateNormals
|
| lat_long_tessellation
| read-write, calls GetLatLongTessellation/SetLatLongTessellation
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkSphereSource:
|
| __vtkname__ = 'vtkSphereSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.Spline
Python Library Documentation: function Spline in module pyvista.core.utilities.parametric_objects
Spline(points: 'VectorLike[float] | MatrixLike[float]', n_points: 'int | None' = None, *, closed: 'bool' = False, parametrize_by: '_ParametrizeByOptions' = 'length', boundary_constraints: '_BoundaryConstraintOptions | tuple[_BoundaryConstraintOptions, _BoundaryConstraintOptions]' = 'clamped', boundary_values: 'float | tuple[float | None, float | None] | None' = None, **kwargs) -> 'PolyData'
Create a spline from points.
Parameters
----------
points : numpy.ndarray
Array of points to build a spline out of. Array must be 3D and
directionally ordered.
n_points : int, optional
Number of points to interpolate along the points array. Defaults to
``points.shape[0]``.
closed : bool, default: False
Close the spline if ``True`` (both ends are joined). Not closed by default.
parametrize_by : str, default: 'length'
Parametrize spline by ``'length'`` or by point ``'index'``.
boundary_constraints : str | Sequence[str], optional, default: 'clamped'
Derivative constraint type at both boundaries of the spline.
Can be set by a single string or a sequence of length 2 (one for each left/right end).
Each value must be one of:
- ``'finite_difference'``: The first derivative at the left(right) most point is determined
from the line defined from the first(last) two points.
- ``'clamped'``: Default: the first derivative at the left(right) most point is set to
Left(Right) ``boundary_values``. (Default)
- ``'second'``: The second derivative at the left(right) most point is set to
Left(Right) ``boundary_values``.
- ``'scaled_second'``: The second derivative at left(right) most points is
Left(Right) ``boundary_values`` times second derivative at first interior point.
boundary_values : float | Sequence[float | None], optional
Values of derivative at both ends of the spline used by the ``boundary_constraints`` type.
Can be set a single float, or a sequence of floats or None (one value for each left/right
end). If a single value is provided, the same value is used for both ends.
Value must be None for each end with boundary constraint type ``'finite_difference'``.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
Line mesh of spline.
See Also
--------
:ref:`create_spline_example`
:ref:`distance_along_spline_example`
Examples
--------
Construct a spline.
>>> import numpy as np
>>> import pyvista as pv
>>> theta = np.linspace(-4 * np.pi, 4 * np.pi, 100)
>>> z = np.linspace(-2, 2, 100)
>>> r = z**2 + 1
>>> x = r * np.sin(theta)
>>> y = r * np.cos(theta)
>>> points = np.column_stack((x, y, z))
>>> spline = pv.Spline(points, 1000)
>>> spline.plot(
... render_lines_as_tubes=True,
... line_width=10,
... show_scalar_bar=False,
... )
pyvista.StructuredGrid
Python Library Documentation: class StructuredGrid in module pyvista.core.pointset
class StructuredGrid(PointGrid, pyvista.core.filters.structured_grid.StructuredGridFilters, vtkmodules.vtkCommonDataModel.vtkStructuredGrid)
| StructuredGrid(*args, **kwargs) -> '_T'
|
| Dataset used for topologically regular arrays of data.
|
| Can be initialized in one of the following several ways:
|
| * Create empty grid.
| * Initialize from a filename.
| * Initialize from a :vtk:`vtkStructuredGrid` object.
| * Initialize directly from one or more :class:`numpy.ndarray`. See the
| example or the documentation of ``uinput``.
|
| Parameters
| ----------
| uinput : str, Path, :vtk:`vtkStructuredGrid`, numpy.ndarray, optional
| Filename, dataset, or array to initialize the structured grid from. If
| a filename is passed, pyvista will attempt to load it as a
| :class:`StructuredGrid`. If passed a :vtk:`vtkStructuredGrid`, it will
| be wrapped as a deep copy.
|
| If a :class:`numpy.ndarray` is provided and ``y`` and ``z`` are empty,
| this array will define the points of this :class:`StructuredGrid`.
| Set the dimensions with :attr:`StructuredGrid.dimensions`.
|
| Otherwise, this parameter will be loaded as the ``x`` points, and ``y``
| and ``z`` points must be set. The shape of this array defines the shape
| of the structured data and the shape should be ``(dimx, dimy,
| dimz)``. Missing trailing dimensions are assumed to be ``1``.
|
| y : numpy.ndarray, optional
| Coordinates of the points in y direction. If this is passed, ``uinput``
| must be a :class:`numpy.ndarray` and match the shape of ``y``.
|
| z : numpy.ndarray, optional
| Coordinates of the points in z direction. If this is passed, ``uinput``
| and ``y`` must be a :class:`numpy.ndarray` and match the shape of ``z``.
|
| deep : bool, default: False
| Whether to deep copy a StructuredGrid object.
| Default is ``False``. Keyword only.
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| **kwargs : dict, optional
| Additional keyword arguments passed when reading from a file or loading
| from arrays.
|
| See Also
| --------
| :ref:`create_structured_surface_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import vtk
| >>> import numpy as np
|
| Create an empty structured grid.
|
| >>> grid = pv.StructuredGrid()
|
| Initialize from a :vtk:`vtkStructuredGrid` object
|
| >>> vtkgrid = vtk.vtkStructuredGrid()
| >>> grid = pv.StructuredGrid(vtkgrid)
|
| Create from NumPy arrays using :func:`numpy.meshgrid`.
|
| >>> xrng = np.linspace(-5, 5, 10)
| >>> yrng = np.linspace(-8, 8, 4)
| >>> zrng = np.linspace(-7, 4, 20)
| >>> x, y, z = np.meshgrid(xrng, yrng, zrng, indexing='ij')
| >>> grid = pv.StructuredGrid(x, y, z)
| >>> grid
| StructuredGrid (...)
| N Cells: 513
| N Points: 800
| X Bounds: -5.000e+00, 5.000e+00
| Y Bounds: -8.000e+00, 8.000e+00
| Z Bounds: -7.000e+00, 4.000e+00
| Dimensions: 10, 4, 20
| N Arrays: 0
|
| Note how the grid dimensions match the shape of the input arrays.
|
| >>> (xrng.size, yrng.size, zrng.size)
| (10, 4, 20)
|
| Method resolution order:
| StructuredGrid
| PointGrid
| _PointSet
| pyvista.core.dataset.DataSet
| pyvista.core.filters.structured_grid.StructuredGridFilters
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkStructuredGrid
| vtkmodules.vtkCommonDataModel.vtkPointSet
| vtkmodules.vtkCommonDataModel.vtkDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __getitem__(self, key)
| Slice subsets of the StructuredGrid, or extract an array field.
|
| __init__(self, uinput=None, y=None, z=None, *args, deep: 'bool' = False, validate: 'bool | _NestedMeshValidationFields' = False, **kwargs) -> 'None'
| Initialize the structured grid.
|
| __repr__(self)
| Return the standard representation.
|
| __str__(self)
| Return the standard str representation.
|
| cast_to_explicit_structured_grid(self) -> 'ExplicitStructuredGrid'
| Cast to an explicit structured grid.
|
| Returns
| -------
| pyvista.ExplicitStructuredGrid
| An explicit structured grid.
|
| Raises
| ------
| TypeError
| If the structured grid is not 3D (i.e., any dimension is 1).
|
| hide_cells(self, ind, inplace: 'bool' = False) -> 'Self'
| Hide cells without deleting them.
|
| Hides cells by setting the ghost_cells array to ``HIDDEN_CELL``.
|
| Parameters
| ----------
| ind : sequence[int]
| List or array of cell indices to be hidden. The array can
| also be a boolean array of the same size as the number of
| cells.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.StructuredGrid
| Structured grid with hidden cells.
|
| Examples
| --------
| Hide part of the middle of a structured surface.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> x = np.arange(-10, 10, 0.25)
| >>> y = np.arange(-10, 10, 0.25)
| >>> z = 0
| >>> x, y, z = np.meshgrid(x, y, z)
| >>> grid = pv.StructuredGrid(x, y, z)
| >>> grid = grid.hide_cells(range(79 * 30, 79 * 50))
| >>> grid.plot(color=True, show_edges=True)
|
| hide_points(self, ind: 'VectorLike[bool] | VectorLike[int]') -> 'None'
| Hide points without deleting them.
|
| Hides points by setting the ghost_points array to ``HIDDEN_CELL``.
|
| Parameters
| ----------
| ind : VectorLike[bool] | VectorLike[int]
| Vector of point indices to be hidden. The vector can also be a
| boolean array of the same size as the number of points.
|
| Examples
| --------
| Hide part of the middle of a structured surface.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> x = np.arange(-10, 10, 0.25)
| >>> y = np.arange(-10, 10, 0.25)
| >>> z = 0
| >>> x, y, z = np.meshgrid(x, y, z)
| >>> grid = pv.StructuredGrid(x, y, z)
| >>> grid.hide_points(range(80 * 30, 80 * 50))
| >>> grid.plot(color=True, show_edges=True)
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| points_matrix
| Points as a 4-D matrix, with x/y/z along the last dimension.
|
| x
| Return the X coordinates of all points.
|
| Returns
| -------
| numpy.ndarray
| Numpy array of all X coordinates.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> xrng = np.arange(-10, 10, 1, dtype=np.float32)
| >>> yrng = np.arange(-10, 10, 2, dtype=np.float32)
| >>> zrng = np.arange(-10, 10, 5, dtype=np.float32)
| >>> x, y, z = np.meshgrid(xrng, yrng, zrng, indexing='ij')
| >>> grid = pv.StructuredGrid(x, y, z)
| >>> grid.x.shape
| (20, 10, 4)
|
| y
| Return the Y coordinates of all points.
|
| z
| Return the Z coordinates of all points.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| dimensions
| Return a length 3 tuple of the grid's dimensions.
|
| Returns
| -------
| tuple
| Grid dimensions.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> xrng = np.arange(-10, 10, 1, dtype=np.float32)
| >>> yrng = np.arange(-10, 10, 2, dtype=np.float32)
| >>> zrng = np.arange(-10, 10, 5, dtype=np.float32)
| >>> x, y, z = np.meshgrid(xrng, yrng, zrng, indexing='ij')
| >>> grid = pv.StructuredGrid(x, y, z)
| >>> grid.dimensions
| (20, 10, 4)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[StructuredGrid...
|
| ----------------------------------------------------------------------
| Methods inherited from PointGrid:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| plot_curvature(self: 'Self', curv_type='mean', **kwargs)
| Plot the curvature of the external surface of the grid.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| One of the following strings indicating curvature types.
| - ``'mean'``
| - ``'gaussian'``
| - ``'maximum'``
| - ``'minimum'``
|
| **kwargs : dict, optional
| Optional keyword arguments. See :func:`pyvista.plot`.
|
| Returns
| -------
| list
| Camera position, focal point, and view up. Returned when
| ``return_cpos`` is ``True``.
|
| ----------------------------------------------------------------------
| Methods inherited from _PointSet:
|
| center_of_mass(self, scalars_weight: 'bool' = False) -> 'NumpyArray[float]'
| Return the coordinates for the center of mass of the mesh.
|
| Parameters
| ----------
| scalars_weight : bool, default: False
| Flag for using the mesh scalars as weights.
|
| Returns
| -------
| numpy.ndarray
| Coordinates for the center of mass.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 1, 1))
| >>> mesh.center_of_mass()
| array([1., 1., 1.])
|
| points_to_double(self) -> 'Self'
| Convert the points datatype to double precision.
|
| Returns
| -------
| pyvista.PointSet
| Pointset with points in double precision.
|
| Notes
| -----
| This operates in place.
|
| Examples
| --------
| Create a mesh that has points of the type ``float32`` and
| convert the points to ``float64``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.points.dtype
| dtype('float32')
| >>> _ = mesh.points_to_double()
| >>> mesh.points.dtype
| dtype('float64')
|
| remove_cells(self, ind: 'VectorLike[bool] | VectorLike[int]', inplace: 'bool' = False) -> '_PointSet'
| Remove cells.
|
| Parameters
| ----------
| ind : VectorLike[int] | VectorLike[bool]
| Cell indices to be removed. The array can also be a
| boolean array of the same size as the number of cells.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| Returns
| -------
| pyvista.DataSet
| Same type as the input, but with the specified cells
| removed.
|
| See Also
| --------
| :ref:`ghost_cells_example`
|
| Examples
| --------
| Remove 20 cells from an unstructured grid.
|
| >>> from pyvista import examples
| >>> import pyvista as pv
| >>> hex_mesh = pv.read(examples.hexbeamfile)
| >>> removed = hex_mesh.remove_cells(range(10, 20))
| >>> removed.plot(color='lightblue', show_edges=True, line_width=3)
|
| shallow_copy(self, to_copy: 'DataSet') -> 'None'
| Create a shallow copy from a different dataset into this one.
|
| This method mutates this dataset and returns ``None``.
|
| Parameters
| ----------
| to_copy : pyvista.DataSet
| Data object to perform the shallow copy from.
|
| translate(self: 'Self', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False)
| Translate the mesh.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats of cartesian values to translate the mesh with.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed. This is
| only valid when not updating in place.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PointSet
| Translated pointset.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=True)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.structured_grid.StructuredGridFilters:
|
| concatenate(self, other, axis, tolerance=0.0)
| Concatenate a structured grid to this grid.
|
| Joins structured grids into a single structured grid. Grids
| must be of compatible dimension, and must be coincident along
| the seam. Grids must have the same point and cell data. Field
| data is ignored.
|
| Parameters
| ----------
| other : pyvista.StructuredGrid
| Structured grid to concatenate.
|
| axis : int
| Axis along which to concatenate.
|
| tolerance : float, default: 0.0
| Tolerance for point coincidence along joining seam.
|
| Returns
| -------
| pyvista.StructuredGrid
| Concatenated grid.
|
| Examples
| --------
| Split a grid in half and join them.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_structured()
| >>> voi_1 = grid.extract_subset([0, 80, 0, 40, 0, 1], boundary=True)
| >>> voi_2 = grid.extract_subset([0, 80, 40, 80, 0, 1], boundary=True)
| >>> joined = voi_1.concatenate(voi_2, axis=1)
| >>> f'{grid.dimensions} same as {joined.dimensions}'
| '(80, 80, 1) same as (80, 80, 1)'
|
| extract_subset(self, voi, rate=(1, 1, 1), boundary: 'bool' = False)
| Select piece (e.g., volume of interest).
|
| To use this filter set the VOI ivar which are i-j-k min/max
| indices that specify a rectangular region in the data. (Note
| that these are 0-offset.) You can also specify a sampling rate
| to subsample the data.
|
| Typical applications of this filter are to extract a slice
| from a volume for image processing, subsampling large volumes
| to reduce data size, or extracting regions of a volume with
| interesting data.
|
| Parameters
| ----------
| voi : sequence[int]
| Length 6 iterable of ints: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| These bounds specify the volume of interest in i-j-k min/max
| indices.
|
| rate : sequence[int], default: (1, 1, 1)
| Length 3 iterable of ints: ``(xrate, yrate, zrate)``.
|
| boundary : bool, default: False
| Control whether to enforce that the "boundary" of the grid
| is output in the subsampling process. (This only has
| effect when the rate in any direction is not equal to
| 1). When this is on, the subsampling will always include
| the boundary of the grid even if the sample rate is
| not an even multiple of the grid dimensions.
|
| Returns
| -------
| pyvista.StructuredGrid
| StructuredGrid with extracted subset.
|
| Examples
| --------
| Split a grid in half.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_structured()
| >>> voi_1 = grid.extract_subset([0, 80, 0, 40, 0, 1], boundary=True)
| >>> voi_2 = grid.extract_subset([0, 80, 40, 80, 0, 1], boundary=True)
|
| For fun, add the two grids back together and show they are
| identical to the original grid.
|
| >>> joined = voi_1.concatenate(voi_2, axis=1)
| >>> assert np.allclose(grid.points, joined.points)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkStructuredGrid:
|
| BlankCell(...)
| BlankCell(self, ptId:int) -> None
| C++: void BlankCell(vtkIdType ptId)
|
| Methods for supporting blanking of cells. Blanking turns on or
| off cells in the structured grid, and hence the points connected
| to them. These methods should be called only after the dimensions
| of the grid are set.
|
| BlankPoint(...)
| BlankPoint(self, ptId:int) -> None
| C++: void BlankPoint(vtkIdType ptId)
|
| Methods for supporting blanking of cells. Blanking turns on or
| off points in the structured grid, and hence the cells connected
| to them. These methods should be called only after the dimensions
| of the grid are set.
|
| CopyStructure(...)
| CopyStructure(self, ds:vtkDataSet) -> None
| C++: void CopyStructure(vtkDataSet *ds) override;
|
| Copy the geometric and topological structure of an input poly
| data object.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: void Crop(const int *updateExtent) override;
|
| Reallocates and copies to set the Extent to the UpdateExtent.
| This is used internally when the exact extent is requested, and
| the source generated more than the update extent.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| ExtendedNew(...)
| ExtendedNew() -> vtkStructuredGrid
| C++: static vtkStructuredGrid *ExtendedNew()
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated. The
| memory size returned is guaranteed to be greater than or equal to
| the memory required to represent the data (e.g., extra space in
| arrays, etc. are not included in the return value). THIS METHOD
| IS THREAD SAFE.
|
| GetCell(...)
| GetCell(self, cellId:int) -> vtkCell
| C++: vtkCell *GetCell(vtkIdType cellId) override;
| GetCell(self, i:int, j:int, k:int) -> vtkCell
| C++: vtkCell *GetCell(int i, int j, int k) override;
| GetCell(self, cellId:int, cell:vtkGenericCell) -> None
| C++: void GetCell(vtkIdType cellId, vtkGenericCell *cell)
| override;
|
| This method always return a `vtkEmptyCell`, as there is no cell
| in a `vtkPointSet`.
|
| GetCellBounds(...)
| GetCellBounds(self, cellId:int, bounds:[float, float, float,
| float, float, float]) -> None
| C++: void GetCellBounds(vtkIdType cellId, double bounds[6])
| override;
|
| Get the bounds of the cell with cellId such that: 0 <= cellId <
| NumberOfCells. A subclass may be able to determine the bounds of
| cell without using an expensive GetCell() method. A default
| implementation is provided that actually uses a GetCell() call.
| This is to ensure the method is available to all datasets.
| Subclasses should override this method to provide an efficient
| implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetCellDims(...)
| GetCellDims(self, cellDims:[int, int, int]) -> None
| C++: void GetCellDims(int cellDims[3])
|
| Given the node dimensions of this grid instance, this method
| computes the node dimensions. The value in each dimension can
| will have a lowest value of "1" such that computing the total
| number of cells can be achieved by simply by
| cellDims[0]*cellDims[1]*cellDims[2].
|
| GetCellNeighbors(...)
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds) override;
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList, seedLoc:[int, ...]) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds, int *seedLoc)
|
| Topological inquiry to get all cells using list of points
| exclusive of cell specified (e.g., cellId). Note that the list
| consists of only cells that use ALL the points provided. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetCellPoints(...)
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...),
| ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts, vtkIdList *ptIds) override;
| GetCellPoints(self, cellId:int, ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
| override;
|
| Topological inquiry to get points defining cell.
|
| This function MAY use ptIds, which is an object that is created
| by each thread, to guarantee thread safety.
|
| @warning Subsequent calls to this method may invalidate previous
| call
| results.
|
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetCellSize(...)
| GetCellSize(self, cellId:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType cellId) override;
|
| This method always returns 1, as all cells are point in a pure
| `vtkPointSet`.
|
| GetCellType(...)
| GetCellType(self, cellId:int) -> int
| C++: int GetCellType(vtkIdType cellId) override;
|
| This method always returns `VTK_EMPTY_CELL`, as there is no cell
| in a `vtkPointSet`.
|
| GetCellTypes(...)
| GetCellTypes(self) -> vtkConstantArray_IhE
| C++: vtkConstantArray<unsigned char> *GetCellTypes()
| GetCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetCellTypes(vtkCellTypes *types)
|
| GetCellTypesArray(...)
| GetCellTypesArray(self) -> vtkConstantArray_IiE
| C++: vtkConstantArray<int> *GetCellTypesArray()
|
| GetCells(...)
| GetCells(self) -> vtkStructuredCellArray
| C++: vtkStructuredCellArray *GetCells()
|
| Return the structured grid connectivity array.
|
| NOTE: the returned object should not be modified.
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkStructuredGrid
| C++: static vtkStructuredGrid *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkStructuredGrid
| C++: static vtkStructuredGrid *GetData(vtkInformationVector *v,
| int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataDescription(...)
| GetDataDescription(self) -> int
| C++: virtual int GetDataDescription()
|
| Get the data description of the structured grid.
|
| GetDataDimension(...)
| GetDataDimension(self) -> int
| C++: int GetDataDimension()
|
| Return the dimensionality of the data.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return what type of dataset this is.
|
| GetDimensions(...)
| GetDimensions(self, dims:[int, int, int]) -> None
| C++: virtual void GetDimensions(int dims[3])
|
| Get dimensions of this structured grid based on its extent.
|
| GetExtent(...)
| GetExtent(self) -> (int, int, int, int, int, int)
| C++: virtual int *GetExtent()
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: int GetExtentType() override;
|
| The extent type is a 3D extent
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Convenience method returns largest cell size in dataset. This is
| generally used to allocate memory for supporting data structures.
| THIS METHOD IS THREAD SAFE
|
| GetMaxSpatialDimension(...)
| GetMaxSpatialDimension(self) -> int
| C++: int GetMaxSpatialDimension() override;
|
| Get the maximum/minimum spatial dimensionality of the data which
| is the maximum/minimum dimension of all cells.
|
| @warning This method MUST be overridden for performance reasons.
| Default implementation is very inefficient.
|
| GetMinSpatialDimension(...)
| GetMinSpatialDimension(self) -> int
| C++: int GetMinSpatialDimension() override;
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| Standard vtkDataSet API methods. See vtkDataSet for more
| information.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| See vtkDataSet for additional information.
|
| GetPoint(...)
| GetPoint(self, ptId:int) -> (float, float, float)
| C++: double *GetPoint(vtkIdType ptId) override;
| GetPoint(self, ptId:int, p:[float, float, float]) -> None
| C++: void GetPoint(vtkIdType ptId, double p[3]) override;
| GetPoint(self, i:int, j:int, k:int, p:[float, float, float],
| adjustForExtent:bool=True) -> None
| C++: void GetPoint(int i, int j, int k, double p[3],
| bool adjustForExtent=true)
|
| See vtkDataSet for additional information. WARNING: Just don't
| use this error-prone method, the returned pointer and its values
| are only valid as long as another method invocation is not
| performed. Prefer GetPoint() with the return value in argument.
|
| GetPointCells(...)
| GetPointCells(self, ptId:int, cellIds:vtkIdList) -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
| override;
|
| Topological inquiry to get cells using point. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| HasAnyBlankCells(...)
| HasAnyBlankCells(self) -> bool
| C++: bool HasAnyBlankCells() override;
|
| Returns 1 if there is any visibility constraint on the cells, 0
| otherwise.
|
| HasAnyBlankPoints(...)
| HasAnyBlankPoints(self) -> bool
| C++: bool HasAnyBlankPoints() override;
|
| Returns 1 if there is any visibility constraint on the points, 0
| otherwise.
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Restore object to initial state. Release memory back to system.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsCellVisible(...)
| IsCellVisible(self, cellId:int) -> int
| C++: unsigned char IsCellVisible(vtkIdType cellId)
|
| Return non-zero value if specified point is visible. These
| methods should be called only after the dimensions of the grid
| are set.
|
| IsPointVisible(...)
| IsPointVisible(self, ptId:int) -> int
| C++: unsigned char IsPointVisible(vtkIdType ptId)
|
| Return non-zero value if specified point is visible. These
| methods should be called only after the dimensions of the grid
| are set.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkStructuredGrid
| C++: vtkStructuredGrid *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkStructuredGrid
| C++: static vtkStructuredGrid *SafeDownCast(vtkObjectBase *o)
|
| SetDimensions(...)
| SetDimensions(self, i:int, j:int, k:int) -> None
| C++: void SetDimensions(int i, int j, int k)
| SetDimensions(self, dims:(int, int, int)) -> None
| C++: void SetDimensions(const int dims[3])
|
| Sets the extent to be 0 to i-1, 0 to j-1, and 0 to k-1.
|
| SetExtent(...)
| SetExtent(self, extent:[int, int, int, int, int, int]) -> None
| C++: void SetExtent(int extent[6])
| SetExtent(self, xMin:int, xMax:int, yMin:int, yMax:int, zMin:int,
| zMax:int) -> None
| C++: void SetExtent(int xMin, int xMax, int yMin, int yMax,
| int zMin, int zMax)
|
| Different ways to set the extent of the data array. The extent
| should be set before the "Scalars" are set or allocated. The
| Extent is stored in the order (X, Y, Z).
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| UnBlankCell(...)
| UnBlankCell(self, ptId:int) -> None
| C++: void UnBlankCell(vtkIdType ptId)
|
| UnBlankPoint(...)
| UnBlankPoint(self, ptId:int) -> None
| C++: void UnBlankPoint(vtkIdType ptId)
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkStructuredGrid:
|
| __this__
| Pointer to the C++ object.
|
| cell_types
| read-only, calls GetCellTypes
|
| cell_types_array
| read-only, calls GetCellTypesArray
|
| cells
| read-only, calls GetCells
|
| data_description
| read-only, calls GetDataDescription
|
| data_dimension
| read-only, calls GetDataDimension
|
| data_object_type
| read-only, calls GetDataObjectType
|
| extent
| read-write, calls GetExtent/SetExtent
|
| extent_type
| read-only, calls GetExtentType
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| max_spatial_dimension
| read-only, calls GetMaxSpatialDimension
|
| min_spatial_dimension
| read-only, calls GetMinSpatialDimension
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkStructuredGrid:
|
| __vtkname__ = 'vtkStructuredGrid'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| BuildCellLocator(...)
| BuildCellLocator(self) -> None
| C++: void BuildCellLocator()
|
| Build the cell locator. In a multi-threaded environment, call
| this method in a single thread before using FindCell().
|
| BuildLocator(...)
| BuildLocator(self) -> None
| C++: void BuildLocator()
|
| BuildPointLocator(...)
| BuildPointLocator(self) -> None
| C++: void BuildPointLocator()
|
| Build the internal point locator . In a multi-threaded
| environment, call this method in a single thread before using
| FindCell() or FindPoint().
|
| ComputeBounds(...)
| ComputeBounds(self) -> None
| C++: void ComputeBounds() override;
|
| Compute the (X, Y, Z) bounds of the data.
|
| EditableOff(...)
| EditableOff(self) -> None
| C++: virtual void EditableOff()
|
| EditableOn(...)
| EditableOn(self) -> None
| C++: virtual void EditableOn()
|
| FindCell(...)
| FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int,
| tol2:float, subId:int, pcoords:[float, float, float],
| weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
| FindCell(self, x:[float, float, float], cell:vtkCell,
| gencell:vtkGenericCell, cellId:int, tol2:float, subId:int,
| pcoords:[float, float, float], weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkGenericCell *gencell, vtkIdType cellId, double tol2,
| int &subId, double pcoords[3], double *weights) override;
|
| Locate cell based on global coordinate x and tolerance squared.
| If cell and cellId is non-nullptr, then search starts from this
| cell and looks at immediate neighbors. Returns cellId >= 0 if
| inside, < 0 otherwise. The parametric coordinates are provided
| in pcoords[3]. The interpolation weights are returned in
| weights[]. (The number of weights is equal to the number of
| points in the found cell). Tolerance is used to control how close
| the point is to be considered "in" the cell. THIS METHOD IS NOT
| THREAD SAFE.
|
| FindPoint(...)
| FindPoint(self, x:[float, float, float]) -> int
| C++: vtkIdType FindPoint(double x[3]) override;
|
| GetCellLocator(...)
| GetCellLocator(self) -> vtkAbstractCellLocator
| C++: virtual vtkAbstractCellLocator *GetCellLocator()
|
| GetEditable(...)
| GetEditable(self) -> bool
| C++: virtual bool GetEditable()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Get MTime which also considers its vtkPoints MTime.
|
| GetPointLocator(...)
| GetPointLocator(self) -> vtkAbstractPointLocator
| C++: virtual vtkAbstractPointLocator *GetPointLocator()
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints() override;
|
| If the subclass has (implicit/explicit) points, then return them.
| Otherwise, create a vtkPoints object and return that.
|
| DO NOT MODIFY THE RETURNED POINTS OBJECT.
|
| NewCellIterator(...)
| NewCellIterator(self) -> vtkCellIterator
| C++: vtkCellIterator *NewCellIterator() override;
|
| Return an iterator that traverses the cells in this data set.
|
| SetCellLocator(...)
| SetCellLocator(self, __a:vtkAbstractCellLocator) -> None
| C++: virtual void SetCellLocator(vtkAbstractCellLocator *)
|
| Set / get an instance of vtkAbstractCellLocator which may be used
| when a vtkCellLocatorStrategy is used during a FindCell()
| operation.
|
| SetEditable(...)
| SetEditable(self, _arg:bool) -> None
| C++: virtual void SetEditable(bool _arg)
|
| Specify whether this dataset is editable after creation. Meaning,
| once the points and cells are defined, can the dataset be
| incrementally modified. By default, this dataset is non-editable
| (i.e., "static") after construction. The reason for this is
| performance: cell links and locators can be built (and destroyed)
| much faster is it is known that the data is static (see
| vtkStaticCellLinks, vtkStaticPointLocator, vtkStaticCellLocator).
|
| SetPointLocator(...)
| SetPointLocator(self, __a:vtkAbstractPointLocator) -> None
| C++: virtual void SetPointLocator(vtkAbstractPointLocator *)
|
| Set / get an instance of vtkAbstractPointLocator which is used to
| support the FindPoint() and FindCell() methods. By default a
| vtkStaticPointLocator is used, unless the class is set as
| Editable, in which case a vtkPointLocator is used.
|
| SetPoints(...)
| SetPoints(self, __a:vtkPoints) -> None
| C++: virtual void SetPoints(vtkPoints *)
|
| Specify point array to define point coordinates.
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: void Squeeze() override;
|
| Reclaim any unused memory.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Overwritten to handle the data/locator loop
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| cell_locator
| read-write, calls GetCellLocator/SetCellLocator
|
| editable
| read-write, calls GetEditable/SetEditable
|
| m_time
| read-only, calls GetMTime
|
| point_locator
| read-write, calls GetPointLocator/SetPointLocator
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| AllocateCellGhostArray(...)
| AllocateCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocateCellGhostArray()
|
| Allocate ghost array for cells.
|
| AllocatePointGhostArray(...)
| AllocatePointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocatePointGhostArray()
|
| Allocate ghost array for points.
|
| CheckAttributes(...)
| CheckAttributes(self) -> int
| C++: int CheckAttributes()
|
| This method checks to see if the cell and point attributes match
| the geometry. Many filters will crash if the number of tuples in
| an array is less than the number of points/cells. This method
| returns 1 if there is a mismatch, and 0 if everything is ok. It
| prints an error if an array is too short, and a warning if an
| array is too long.
|
| CopyAttributes(...)
| CopyAttributes(self, ds:vtkDataSet) -> None
| C++: virtual void CopyAttributes(vtkDataSet *ds)
|
| Copy the attributes associated with the specified dataset to this
| instance of vtkDataSet. THIS METHOD IS NOT THREAD SAFE.
|
| FindAndGetCell(...)
| FindAndGetCell(self, x:[float, float, float], cell:vtkCell,
| cellId:int, tol2:float, subId:int, pcoords:[float, float,
| float], weights:[float, ...]) -> vtkCell
| C++: virtual vtkCell *FindAndGetCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights)
|
| Locate the cell that contains a point and return the cell. Also
| returns the subcell id, parametric coordinates and weights for
| subsequent interpolation. This method combines the derived class
| methods int FindCell and vtkCell *GetCell. Derived classes may
| provide a more efficient implementation. See for example
| vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE.
|
| GenerateGhostArray(...)
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int])
| -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6])
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int],
| cellOnly:bool) -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6],
| bool cellOnly)
|
| Normally called by pipeline executives or algorithms only. This
| method computes the ghost arrays for a given dataset. The zeroExt
| argument specifies the extent of the region which ghost type = 0.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return a pointer to the geometry bounding box in the form
| (xmin,xmax, ymin,ymax, zmin,zmax). THIS METHOD IS NOT THREAD
| SAFE.
|
| GetCellData(...)
| GetCellData(self) -> vtkCellData
| C++: vtkCellData *GetCellData()
|
| Return a pointer to this dataset's cell data. THIS METHOD IS
| THREAD SAFE
|
| GetCellGhostArray(...)
| GetCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellGhostArray()
|
| Get the array that defines the ghost type of each cell. We cache
| the pointer to the array to save a lookup involving string
| comparisons
|
| GetCellNumberOfFaces(...)
| GetCellNumberOfFaces(self, cellId:int, cellType:int,
| cell:vtkGenericCell) -> int
| C++: virtual int GetCellNumberOfFaces(vtkIdType cellId,
| unsigned char &cellType, vtkGenericCell *cell)
|
| Get the number of faces of a cell.
|
| Most of the times extracting the number of faces requires only
| extracting the cell type. However, for some cell types, the
| number of faces is not constant. For example, a convex point set
| cell can have a different number of faces for each cell. That's
| why this method requires the cell id and the dataset.
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: double *GetCenter()
| GetCenter(self, center:[float, float, float]) -> None
| C++: void GetCenter(double center[3])
|
| Get the center of the bounding box. THIS METHOD IS NOT THREAD
| SAFE.
|
| GetDistinctCellTypes(...)
| GetDistinctCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetDistinctCellTypes(vtkCellTypes *types)
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset 5 triangles, 3 lines, and
| 100 hexahedra would result a list of three entries, corresponding
| to the types VTK_TRIANGLE, VTK_LINE, and VTK_HEXAHEDRON. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetGhostArray(int type) override;
|
| Returns the ghost array for the given type (point or cell). Takes
| advantage of the cache with the pointer to the array to save a
| string comparison.
|
| GetLength(...)
| GetLength(self) -> float
| C++: double GetLength()
|
| Return the length of the diagonal of the bounding box. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Return the squared length of the diagonal of the bounding box.
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetMeshMTime(...)
| GetMeshMTime(self) -> int
| C++: virtual vtkMTimeType GetMeshMTime()
|
| Abstract method which return the mesh (geometry/topology)
| modification time. This time is different from the usual MTime
| which also takes into account the modification of data arrays.
| This function can be used to track the changes on the mesh
| separately from the data arrays (eg. static mesh over time with
| transient data). The default implementation returns the MTime. It
| is up to subclasses to provide a better approach.
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| GetPointData(...)
| GetPointData(self) -> vtkPointData
| C++: vtkPointData *GetPointData()
|
| Return a pointer to this dataset's point data. THIS METHOD IS
| THREAD SAFE
|
| GetPointGhostArray(...)
| GetPointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetPointGhostArray()
|
| Gets the array that defines the ghost type of each point. We
| cache the pointer to the array to save a lookup involving string
| comparisons
|
| GetScalarRange(...)
| GetScalarRange(self, range:[float, float]) -> None
| C++: virtual void GetScalarRange(double range[2])
| GetScalarRange(self) -> (float, float)
| C++: double *GetScalarRange()
|
| Convenience method to get the range of the first component (and
| only the first component) of any scalars in the data set. If the
| data has both point data and cell data, it returns the (min/max)
| range of combined point and cell data. If there are no point or
| cell scalars the method will return (0,1). Note: It might be
| necessary to call Update to create or refresh the scalars before
| calling this method. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| HasAnyGhostCells(...)
| HasAnyGhostCells(self) -> bool
| C++: bool HasAnyGhostCells()
|
| Returns 1 if there are any ghost cells 0 otherwise.
|
| HasAnyGhostPoints(...)
| HasAnyGhostPoints(self) -> bool
| C++: bool HasAnyGhostPoints()
|
| Returns 1 if there are any ghost points 0 otherwise.
|
| SetCellOrderAndRationalWeights(...)
| SetCellOrderAndRationalWeights(self, cellId:int,
| cell:vtkGenericCell) -> None
| C++: void SetCellOrderAndRationalWeights(vtkIdType cellId,
| vtkGenericCell *cell)
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| cell_ghost_array
| read-only, calls GetCellGhostArray
|
| length2
| read-only, calls GetLength2
|
| mesh_m_time
| read-only, calls GetMeshMTime
|
| point_ghost_array
| read-only, calls GetPointGhostArray
|
| scalar_range
| read-only, calls GetScalarRange
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| CELL_DATA_FIELD = 2
|
| DATA_OBJECT_FIELD = 0
|
| FieldDataType = <class 'vtkmodules.vtkCommonDataModel.vtkDataSet.Field...
|
| POINT_DATA_FIELD = 1
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.StructuredGridWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.Superquadric
Python Library Documentation: function Superquadric in module pyvista.core.utilities.geometric_objects
Superquadric(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), scale: 'VectorLike[float]' = (1.0, 1.0, 1.0), size: 'float' = 0.5, theta_roundness: 'float' = 1.0, phi_roundness: 'float' = 1.0, theta_resolution: 'int' = 16, phi_resolution: 'int' = 16, toroidal: 'bool' = False, thickness: 'float' = 0.3333333333333333) -> 'PolyData'
Create a superquadric.
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Center of the superquadric in ``[x, y, z]``.
scale : sequence[float], default: (1.0, 1.0, 1.0)
Scale factors of the superquadric in ``[x, y, z]``.
size : float, default: 0.5
Superquadric isotropic size.
theta_roundness : float, default: 1.0
Superquadric east/west roundness.
Values range from 0 (rectangular) to 1 (circular) to higher orders.
phi_roundness : float, default: 1.0
Superquadric north/south roundness.
Values range from 0 (rectangular) to 1 (circular) to higher orders.
theta_resolution : int, default: 16
Number of points in the longitude direction.
Values are rounded to nearest multiple of 4.
phi_resolution : int, default: 16
Number of points in the latitude direction.
Values are rounded to nearest multiple of 8.
toroidal : bool, default: False
Whether or not the superquadric is toroidal (``True``)
or ellipsoidal (``False``).
thickness : float, default: 0.3333333333
Superquadric ring thickness.
Only applies if toroidal is set to ``True``.
Returns
-------
pyvista.PolyData
Superquadric mesh.
See Also
--------
pyvista.ParametricSuperEllipsoid :
Parametric superquadric if toroidal is ``False``.
pyvista.ParametricSuperToroid :
Parametric superquadric if toroidal is ``True``.
Examples
--------
>>> import pyvista as pv
>>> superquadric = pv.Superquadric(
... scale=(3.0, 1.0, 0.5),
... phi_roundness=0.1,
... theta_roundness=0.5,
... )
>>> superquadric.plot(show_edges=True)
pyvista.SuperquadricSource
Python Library Documentation: class SuperquadricSource in module pyvista.core.utilities.geometric_sources
class SuperquadricSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkSuperquadricSource)
| SuperquadricSource(*args, **kwargs) -> '_T'
|
| Create superquadric source.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Center of the superquadric in ``[x, y, z]``.
|
| scale : sequence[float], default: (1.0, 1.0, 1.0)
| Scale factors of the superquadric in ``[x, y, z]``.
|
| size : float, default: 0.5
| Superquadric isotropic size.
|
| theta_roundness : float, default: 1.0
| Superquadric east/west roundness.
| Values range from 0 (rectangular) to 1 (circular) to higher orders.
|
| phi_roundness : float, default: 1.0
| Superquadric north/south roundness.
| Values range from 0 (rectangular) to 1 (circular) to higher orders.
|
| theta_resolution : int, default: 16
| Number of points in the longitude direction.
| Values are rounded to nearest multiple of 4.
|
| phi_resolution : int, default: 16
| Number of points in the latitude direction.
| Values are rounded to nearest multiple of 8.
|
| toroidal : bool, default: False
| Whether or not the superquadric is toroidal (``True``)
| or ellipsoidal (``False``).
|
| thickness : float, default: 0.3333333333
| Superquadric ring thickness.
| Only applies if toroidal is set to ``True``.
|
| Method resolution order:
| SuperquadricSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkSuperquadricSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'SuperquadricSource', center: 'VectorLike[float]' = (0.0, 0.0, 0.0), scale: 'VectorLike[float]' = (1.0, 1.0, 1.0), size: 'float' = 0.5, theta_roundness: 'float' = 1.0, phi_roundness: 'float' = 1.0, theta_resolution: 'int' = 16, phi_resolution: 'int' = 16, toroidal: 'bool' = False, thickness: 'float' = 0.3333333333333333) -> 'None'
| Initialize source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Plane mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Center of the superquadric in ``[x, y, z]``.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the superquadric in ``[x, y, z]``.
|
| phi_resolution
| Number of points in the latitude direction.
|
| Returns
| -------
| float
| Number of points in the latitude direction.
|
| phi_roundness
| Superquadric north/south roundness.
|
| Returns
| -------
| float
| Superquadric north/south roundness.
|
| scale
| Scale factors of the superquadric in ``[x, y, z]``.
|
| Returns
| -------
| sequence[float]
| Scale factors of the superquadric in ``[x, y, z]``.
|
| size
| Superquadric isotropic size.
|
| Returns
| -------
| float
| Superquadric isotropic size.
|
| theta_resolution
| Number of points in the longitude direction.
|
| Returns
| -------
| float
| Number of points in the longitude direction.
|
| theta_roundness
| Superquadric east/west roundness.
|
| Returns
| -------
| float
| Superquadric east/west roundness.
|
| thickness
| Superquadric ring thickness.
|
| Returns
| -------
| float
| Superquadric ring thickness.
|
| toroidal
| Whether or not the superquadric is toroidal (``True``) or ellipsoidal (``False``).
|
| Returns
| -------
| bool
| Whether or not the superquadric is toroidal (``True``)
| or ellipsoidal (``False``).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkSuperquadricSource:
|
| GetAxisOfSymmetry(...)
| GetAxisOfSymmetry(self) -> int
| C++: virtual int GetAxisOfSymmetry()
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetPhiResolution(...)
| GetPhiResolution(self) -> int
| C++: virtual int GetPhiResolution()
|
| Set the number of points in the latitude direction. Initial value
| is 16.
|
| GetPhiRoundness(...)
| GetPhiRoundness(self) -> float
| C++: virtual double GetPhiRoundness()
|
| Set/Get Superquadric north/south roundness. Values range from 0
| (rectangular) to 1 (circular) to higher orders. Initial value is
| 1.0.
|
| GetScale(...)
| GetScale(self) -> (float, float, float)
| C++: virtual double *GetScale()
|
| GetSize(...)
| GetSize(self) -> float
| C++: virtual double GetSize()
|
| GetThetaResolution(...)
| GetThetaResolution(self) -> int
| C++: virtual int GetThetaResolution()
|
| Set the number of points in the longitude direction. Initial
| value is 16.
|
| GetThetaRoundness(...)
| GetThetaRoundness(self) -> float
| C++: virtual double GetThetaRoundness()
|
| Set/Get Superquadric east/west roundness. Values range from 0
| (rectangular) to 1 (circular) to higher orders. Initial value is
| 1.0.
|
| GetThickness(...)
| GetThickness(self) -> float
| C++: virtual double GetThickness()
|
| Set/Get Superquadric ring thickness (toroids only). Changing
| thickness maintains the outside diameter of the toroid. Initial
| value is 0.3333.
|
| GetThicknessMaxValue(...)
| GetThicknessMaxValue(self) -> float
| C++: virtual double GetThicknessMaxValue()
|
| GetThicknessMinValue(...)
| GetThicknessMinValue(self) -> float
| C++: virtual double GetThicknessMinValue()
|
| GetToroidal(...)
| GetToroidal(self) -> int
| C++: virtual vtkTypeBool GetToroidal()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkSuperquadricSource
| C++: vtkSuperquadricSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkSuperquadricSource
| C++: static vtkSuperquadricSource *SafeDownCast(vtkObjectBase *o)
|
| SetAxisOfSymmetry(...)
| SetAxisOfSymmetry(self, _arg:int) -> None
| C++: virtual void SetAxisOfSymmetry(int _arg)
|
| Set/Get axis of symmetry for superquadric (x axis: 0, y axis: 1,
| z axis: 2). Initial value is 1.
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set the center of the superquadric. Default is 0,0,0.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetPhiResolution(...)
| SetPhiResolution(self, i:int) -> None
| C++: void SetPhiResolution(int i)
|
| SetPhiRoundness(...)
| SetPhiRoundness(self, e:float) -> None
| C++: void SetPhiRoundness(double e)
|
| SetScale(...)
| SetScale(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetScale(double _arg1, double _arg2,
| double _arg3)
| SetScale(self, _arg:(float, float, float)) -> None
| C++: virtual void SetScale(const double _arg[3])
|
| Set the scale factors of the superquadric. Default is 1,1,1.
|
| SetSize(...)
| SetSize(self, _arg:float) -> None
| C++: virtual void SetSize(double _arg)
|
| Set/Get Superquadric isotropic size. Initial value is 0.5;
|
| SetThetaResolution(...)
| SetThetaResolution(self, i:int) -> None
| C++: void SetThetaResolution(int i)
|
| SetThetaRoundness(...)
| SetThetaRoundness(self, e:float) -> None
| C++: void SetThetaRoundness(double e)
|
| SetThickness(...)
| SetThickness(self, _arg:float) -> None
| C++: virtual void SetThickness(double _arg)
|
| SetToroidal(...)
| SetToroidal(self, _arg:int) -> None
| C++: virtual void SetToroidal(vtkTypeBool _arg)
|
| SetXAxisOfSymmetry(...)
| SetXAxisOfSymmetry(self) -> None
| C++: void SetXAxisOfSymmetry()
|
| SetYAxisOfSymmetry(...)
| SetYAxisOfSymmetry(self) -> None
| C++: void SetYAxisOfSymmetry()
|
| SetZAxisOfSymmetry(...)
| SetZAxisOfSymmetry(self) -> None
| C++: void SetZAxisOfSymmetry()
|
| ToroidalOff(...)
| ToroidalOff(self) -> None
| C++: virtual void ToroidalOff()
|
| ToroidalOn(...)
| ToroidalOn(self) -> None
| C++: virtual void ToroidalOn()
|
| Set/Get whether or not the superquadric is toroidal (1) or
| ellipsoidal (0). Initial value is 0.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkSuperquadricSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkSuperquadricSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkSuperquadricSource:
|
| __this__
| Pointer to the C++ object.
|
| axis_of_symmetry
| read-write, calls GetAxisOfSymmetry/SetAxisOfSymmetry
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkSuperquadricSource:
|
| __vtkname__ = 'vtkSuperquadricSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.TIFFReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.TIFFWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.TYPE_CHECKING
Python Library Documentation: bool object class bool(int) | bool(x) -> bool | | Returns True when the argument x is true, False otherwise. | The builtins True and False are the only two instances of the class bool. | The class bool is a subclass of the class int, and cannot be subclassed. | | Method resolution order: | bool | int | object | | Methods defined here: | | __and__(self, value, /) | Return self&value. | | __invert__(self, /) | ~self | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __repr__(self, /) | Return repr(self). | | __ror__(self, value, /) | Return value|self. | | __rxor__(self, value, /) | Return value^self. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from int: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | True if self else False | | __ceil__(...) | Ceiling of an Integral returns itself. | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floor__(...) | Flooring an Integral returns itself. | | __floordiv__(self, value, /) | Return self//value. | | __format__(self, format_spec, /) | Convert to a string according to format_spec. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(self, /) | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __round__(...) | Rounding an Integral returns itself. | | Rounding with an ndigits argument also returns an integer. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __sizeof__(self, /) | Returns size in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __trunc__(...) | Truncating an Integral returns itself. | | as_integer_ratio(self, /) | Return a pair of integers, whose ratio is equal to the original int. | | The ratio is in lowest terms and has a positive denominator. | | >>> (10).as_integer_ratio() | (10, 1) | >>> (-10).as_integer_ratio() | (-10, 1) | >>> (0).as_integer_ratio() | (0, 1) | | bit_count(self, /) | Number of ones in the binary representation of the absolute value of self. | | Also known as the population count. | | >>> bin(13) | '0b1101' | >>> (13).bit_count() | 3 | | bit_length(self, /) | Number of bits necessary to represent self in binary. | | >>> bin(37) | '0b100101' | >>> (37).bit_length() | 6 | | conjugate(...) | Returns self, the complex conjugate of any int. | | is_integer(self, /) | Returns True. Exists for duck type compatibility with float.is_integer. | | to_bytes(self, /, length=1, byteorder='big', *, signed=False) | Return an array of bytes representing an integer. | | length | Length of bytes object to use. An OverflowError is raised if the | integer is not representable with the given number of bytes. Default | is length 1. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Determines whether two's complement is used to represent the integer. | If signed is False and a negative integer is given, an OverflowError | is raised. | | ---------------------------------------------------------------------- | Class methods inherited from int: | | from_bytes(bytes, byteorder='big', *, signed=False) | Return the integer represented by the given array of bytes. | | bytes | Holds the array of bytes to convert. The argument must either | support the buffer protocol or be an iterable object producing bytes. | Bytes and bytearray are examples of built-in objects that support the | buffer protocol. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Indicates whether two's complement is used to represent the integer. | | ---------------------------------------------------------------------- | Data descriptors inherited from int: | | denominator | the denominator of a rational number in lowest terms | | imag | the imaginary part of a complex number | | numerator | the numerator of a rational number in lowest terms | | real | the real part of a complex number
pyvista.Table
Python Library Documentation: class Table in module pyvista.core.objects
class Table(pyvista.core.dataobject.DataObject, vtkmodules.vtkCommonDataModel.vtkTable)
| Table(*args, **kwargs) -> '_T'
|
| Wrapper for the :vtk:`vtkTable` class.
|
| Create by passing a 2D NumPy array of shape (``n_rows`` by ``n_columns``)
| or from a dictionary containing NumPy arrays.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> arrays = np.random.default_rng().random((100, 3))
| >>> table = pv.Table(arrays)
|
| Method resolution order:
| Table
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkTable
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __arrow_c_stream__(self, requested_schema: 'object | None' = None) -> 'object'
| Export via the Arrow PyCapsule interface.
|
| Implements `the Arrow PyCapsule interface
| <https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html>`_
| by delegating to :meth:`to_arrow`, so pandas, polars, DuckDB,
| ibis, narwhals, and other Arrow-aware consumers can ingest this
| table directly. Scalar 1D columns cross the boundary zero-copy.
|
| Requires :mod:`pyarrow`.
|
| __delitem__(self, name) -> 'None'
| Remove an array by the specified name.
|
| __getitem__(self, index)
| Search row data for an array.
|
| __init__(self, *args, deep: 'bool' = True, **kwargs)
| Initialize the table.
|
| __iter__(self)
| Return the iterator across all arrays.
|
| __repr__(self)
| Return the object representation.
|
| __setitem__(self, name, scalars) -> 'None'
| Add/set an array in the row_arrays.
|
| __str__(self)
| Return the object string representation.
|
| get(self, index)
| Get an array by its name.
|
| Parameters
| ----------
| index : int or str
| Index or name of the row.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| PyVista array.
|
| get_data_range(self, arr: 'str | None' = None, preference: 'FieldLiteral | RowLiteral' = 'row') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr : str, numpy.ndarray, optional
| The name of the array to get the range. If ``None``, the active scalar
| is used.
|
| preference : str, optional
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'row'`` or
| ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the array.
|
| items(self)
| Return the table items.
|
| Returns
| -------
| list
| List containing tuples pairs of the name and array of the table arrays.
|
| keys(self)
| Return the table keys.
|
| Returns
| -------
| list
| List of the array names of this table.
|
| pop(self, name)
| Pop off an array by the specified name.
|
| Parameters
| ----------
| name : int or str
| Index or name of the row array.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| PyVista array.
|
| save(self, *args, **kwargs)
| Save the table.
|
| to_arrow(self) -> 'pyarrow.Table'
| Return this table as a :class:`pyarrow.Table`.
|
| Each row array becomes a column with the same name and dtype.
|
| Requires :mod:`pyarrow`.
|
| Returns
| -------
| pyarrow.Table
| This table represented as an Arrow Table.
|
| Notes
| -----
| 1D contiguous numeric columns wrap the underlying VTK buffer
| zero-copy. Booleans, complex numbers, and strings go through
| pyvista's existing VTK conversion and are copied. Arrow buffers
| are immutable by contract, so consumers cannot mutate VTK memory
| through the returned table.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> table = pv.Table({'a': np.arange(3), 'b': np.array([0.5, 1.5, 2.5])})
| >>> table.to_arrow().schema.names
| ['a', 'b']
|
| to_pandas(self)
| Create a Pandas DataFrame from this Table.
|
| Returns
| -------
| pandas.DataFrame
| This table represented as a pandas dataframe.
|
| update(self, data) -> 'None'
| Set the table data using a dict-like update.
|
| Parameters
| ----------
| data : DataSetAttributes
| Other dataset attributes to update from.
|
| values(self)
| Return the table values.
|
| Returns
| -------
| list
| List of the table arrays.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| is_empty
| Return ``True`` if the table has no rows and no columns.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> table = pv.Table()
| >>> table.is_empty
| True
|
| >>> arrays = np.random.default_rng().random((100, 3))
| >>> table = pv.Table(arrays)
| >>> table.is_empty
| False
|
| n_arrays
| Return the number of columns.
|
| Alias for: ``n_columns``.
|
| Returns
| -------
| int
| The number of columns.
|
| n_columns
| Return the number of columns.
|
| Returns
| -------
| int
| The number of columns.
|
| row_arrays
| Return the all row arrays.
|
| Returns
| -------
| int
| The all row arrays.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| n_rows
| Return the number of rows.
|
| Returns
| -------
| int
| The number of rows.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_meta_from(self: 'Self', *args, **kwargs) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Intended to be overridden by subclasses.
|
| Parameters
| ----------
| *args : tuple
| Positional arguments.
|
| **kwargs : dict, optional
| Keyword arguments.
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkTable:
|
| AddColumn(...)
| AddColumn(self, arr:vtkAbstractArray) -> None
| C++: void AddColumn(vtkAbstractArray *arr)
|
| Add a column to the table.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| Dump(...)
| Dump(self, colWidth:int=16, rowLimit:int=-1, indent:int=0) -> None
| C++: void Dump(unsigned int colWidth=16, int rowLimit=-1,
| unsigned int indent=0)
|
| Dump table contents. If rowLimit is -1 then the full table is
| printed out (Default). If rowLimit is 0 then only the header row
| will be displayed. Otherwise, if rowLimit > 0 then Dump will
| print the first rowLimit rows of data.
|
| If indent is non-zero, the table will be printed with the given
| number of leading spaces.
|
| ExtendedNew(...)
| ExtendedNew() -> vtkTable
| C++: static vtkTable *ExtendedNew()
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated. The
| memory size returned is guaranteed to be greater than or equal to
| the memory required to represent the data (e.g., extra space in
| arrays, etc. are not included in the return value).
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetColumn(...)
| GetColumn(self, col:int) -> vtkAbstractArray
| C++: vtkAbstractArray *GetColumn(vtkIdType col)
|
| Get a column of the table by its column index.
|
| GetColumnByName(...)
| GetColumnByName(self, name:str) -> vtkAbstractArray
| C++: vtkAbstractArray *GetColumnByName(const char *name)
|
| Get a column of the table by its name.
|
| GetColumnIndex(...)
| GetColumnIndex(self, name:str) -> int
| C++: vtkIdType GetColumnIndex(const char *name)
|
| Get the column index for a name. If name is not found returns -1.
|
| GetColumnName(...)
| GetColumnName(self, col:int) -> str
| C++: const char *GetColumnName(vtkIdType col)
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkTable
| C++: static vtkTable *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkTable
| C++: static vtkTable *GetData(vtkInformationVector *v, int i=0)
|
| Retrieve the table from vtkInformation.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return what type of dataset this is.
|
| GetNumberOfColumns(...)
| GetNumberOfColumns(self) -> int
| C++: vtkIdType GetNumberOfColumns()
|
| Get the number of columns in the table.
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (ROW,
| etc.).
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfRows(...)
| GetNumberOfRows(self) -> int
| C++: vtkIdType GetNumberOfRows()
|
| Get the number of rows in the table.
|
| GetRow(...)
| GetRow(self, row:int) -> vtkVariantArray
| C++: vtkVariantArray *GetRow(vtkIdType row)
| GetRow(self, row:int, values:vtkVariantArray) -> None
| C++: void GetRow(vtkIdType row, vtkVariantArray *values)
|
| Get a row of the table as a vtkVariantArray which has one entry
| for each column. NOTE: This version of the method is NOT thread
| safe.
|
| GetRowData(...)
| GetRowData(self) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetRowData()
|
| Get/Set the main data (columns) of the table.
|
| GetValue(...)
| GetValue(self, row:int, col:int) -> vtkVariant
| C++: vtkVariant GetValue(vtkIdType row, vtkIdType col)
|
| Retrieve a value in the table by row and column index as a
| variant. Note that this calls GetValueByName internally so that
| each column array must have its name set (and that name should be
| unique within the table).
|
| GetValueByName(...)
| GetValueByName(self, row:int, col:str) -> vtkVariant
| C++: vtkVariant GetValueByName(vtkIdType row, const char *col)
|
| Retrieve a value in the table by row index and column name as a
| variant.
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Initialize to an empty table.
|
| InsertColumn(...)
| InsertColumn(self, arr:vtkAbstractArray, index:int) -> None
| C++: void InsertColumn(vtkAbstractArray *arr, vtkIdType index)
|
| Insert a column into the table at given column index.
|
| InsertNextBlankRow(...)
| InsertNextBlankRow(self, default_num_val:float=0.0) -> int
| C++: vtkIdType InsertNextBlankRow(double default_num_val=0.0)
|
| Insert a blank row at the end of the table.
|
| InsertNextRow(...)
| InsertNextRow(self, values:vtkVariantArray) -> int
| C++: vtkIdType InsertNextRow(vtkVariantArray *values)
|
| Insert a row at the end of the tablespecified by a
| vtkVariantArray. The number of entries in the array should match
| the number of columns in the table.
|
| InsertRow(...)
| InsertRow(self, row:int) -> None
| C++: void InsertRow(vtkIdType row)
|
| Insert a single row at the index.
|
| InsertRows(...)
| InsertRows(self, row:int, n:int) -> None
| C++: void InsertRows(vtkIdType row, vtkIdType n)
|
| Insert n rows before row. If row < 0 then the rows will be
| prepended to the table.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkTable
| C++: vtkTable *NewInstance()
|
| RemoveAllColumns(...)
| RemoveAllColumns(self) -> None
| C++: void RemoveAllColumns()
|
| Remove all columns from the table.
|
| RemoveAllRows(...)
| RemoveAllRows(self) -> None
| C++: void RemoveAllRows()
|
| Delete all rows from the table. The column arrays are not delete,
| they are just empty after this operation.
|
| RemoveColumn(...)
| RemoveColumn(self, col:int) -> None
| C++: void RemoveColumn(vtkIdType col)
|
| Remove a column from the table by its column index.
|
| RemoveColumnByName(...)
| RemoveColumnByName(self, name:str) -> None
| C++: void RemoveColumnByName(const char *name)
|
| Remove a column from the table by its name.
|
| RemoveRow(...)
| RemoveRow(self, row:int) -> None
| C++: void RemoveRow(vtkIdType row)
|
| Delete a single row from the table. Rows below the deleted row
| are shifted up.
|
| RemoveRows(...)
| RemoveRows(self, row:int, n:int) -> None
| C++: void RemoveRows(vtkIdType row, vtkIdType n)
|
| Delete n rows from the table, starting at row. Rows below the
| deleted rows are shifted up.
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkTable
| C++: static vtkTable *SafeDownCast(vtkObjectBase *o)
|
| SetNumberOfRows(...)
| SetNumberOfRows(self, __a:int) -> None
| C++: void SetNumberOfRows(vtkIdType)
|
| Set the number of rows in the table. Note that memory allocation
| might be performed as a result of this, but no memory will be
| released. Existing data is preserved if the table is expanding.
|
| SetRow(...)
| SetRow(self, row:int, values:vtkVariantArray) -> None
| C++: void SetRow(vtkIdType row, vtkVariantArray *values)
|
| Set a row of the table with a vtkVariantArray which has one entry
| for each column.
|
| SetRowData(...)
| SetRowData(self, data:vtkDataSetAttributes) -> None
| C++: virtual void SetRowData(vtkDataSetAttributes *data)
|
| SetValue(...)
| SetValue(self, row:int, col:int, value:vtkVariant) -> None
| C++: void SetValue(vtkIdType row, vtkIdType col, vtkVariant value)
|
| Set a value in the table by row and column index as a variant.
|
| SetValueByName(...)
| SetValueByName(self, row:int, col:str, value:vtkVariant) -> None
| C++: void SetValueByName(vtkIdType row, const char *col,
| vtkVariant value)
|
| Set a value in the table by row index and column name as a
| variant.
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow/deep copy the data from src into this object.
|
| SqueezeRows(...)
| SqueezeRows(self) -> None
| C++: void SqueezeRows()
|
| Release previously allocated and now unused memory after
| performing resizing operations.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkTable:
|
| __this__
| Pointer to the C++ object.
|
| data_object_type
| read-only, calls GetDataObjectType
|
| number_of_columns
| read-only, calls GetNumberOfColumns
|
| number_of_rows
| read-write, calls GetNumberOfRows/SetNumberOfRows
|
| row_data
| read-write, calls GetRowData/SetRowData
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkTable:
|
| __vtkname__ = 'vtkTable'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: virtual void Crop(const int *updateExtent)
|
| This method crops the data object (if necessary) so that the
| extent matches the update extent.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: virtual int GetExtentType()
|
| The ExtentType will be left as VTK_PIECES_EXTENT for data objects
| such as vtkPolyData and vtkUnstructuredGrid. The ExtentType will
| be changed to VTK_3D_EXTENT for data objects with 3D structure
| such as vtkImageData (and its subclass vtkStructuredPoints),
| vtkRectilinearGrid, and vtkStructuredGrid. The default is the
| have an extent in pieces, with only one piece (no streaming
| possible).
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: virtual vtkUnsignedCharArray *GetGhostArray(int type)
|
| Returns the ghost arrays of the data object of the specified
| attribute type. The type may be: POINT - Defined in
| vtkDataSet subclasses CELL - Defined in vtkDataSet subclasses.
| The other attribute types, will return nullptr since ghosts
| arrays are not defined for now outside of point or cell.
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Data objects are composite objects and need to check each part
| for MTime. The information object also needs to be considered.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: virtual bool SupportsGhostArray(int type)
|
| Returns if this type of data object support ghost array for
| specified type. The type may be: POINT - Defined in
| vtkDataSet subclasses CELL - Defined in vtkDataSet subclasses.
| The other attribute types, will return false since ghosts arrays
| are not defined for now outside of point or cell. for
| vtkDataObject, this always return false but subclasses may
| override this method and implement their own logic.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| extent_type
| read-only, calls GetExtentType
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| m_time
| read-only, calls GetMTime
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.TecplotReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.Tetrahedron
Python Library Documentation: function Tetrahedron in module pyvista.core.utilities.geometric_objects
Tetrahedron(radius: 'float' = 1.0, center: 'VectorLike[float]' = (0.0, 0.0, 0.0)) -> 'PolyData'
Create a tetrahedron of a given size.
A tetrahedron is composed of four congruent equilateral triangles.
Parameters
----------
radius : float, default: 1.0
The radius of the circumscribed sphere for the tetrahedron.
center : sequence[float], default: (0.0, 0.0, 0.0)
Three-length sequence defining the center of the tetrahedron.
Returns
-------
pyvista.PolyData
Mesh for the tetrahedron. Cell scalars are defined that assign
integer labels to each face (with array name ``"FaceIndex"``).
Examples
--------
Create and plot a tetrahedron.
>>> import pyvista as pv
>>> tetra = pv.Tetrahedron()
>>> tetra.plot(categories=True)
See :ref:`create_platonic_solids_example` for more examples using this filter.
pyvista.Text3D
Python Library Documentation: function Text3D in module pyvista.core.utilities.geometric_objects
Text3D(string: 'str', depth: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), normal: 'VectorLike[float]' = (0.0, 0.0, 1.0)) -> 'PolyData'
Create 3D text from a string.
The text may be configured to have a specified width, height or depth.
Parameters
----------
string : str
String to generate 3D text from. If ``None`` or an empty string,
the output mesh will have a single point at ``center``.
depth : float, optional
Depth of the text. If ``None``, the depth is set to half
the ``height`` by default. Set to ``0.0`` for planar
text.
.. versionchanged:: 0.43
The default depth is now calculated dynamically as
half the height. Previously, the default depth had
a fixed value of ``0.5``.
width : float, optional
Width of the text. If ``None``, the width is scaled
proportional to ``height``.
.. versionadded:: 0.43
height : float, optional
Height of the text. If ``None``, the height is scaled
proportional to ``width``.
.. versionadded:: 0.43
center : Sequence[float], default: (0.0, 0.0, 0.0)
Center of the text, defined as the middle of the axis-aligned
bounding box of the text.
.. versionadded:: 0.43
normal : Sequence[float], default: (0.0, 0.0, 1.0)
Normal direction of the text. The direction is parallel to the
``depth`` of the text and points away from the front surface
of the text.
.. versionadded:: 0.43
Returns
-------
pyvista.PolyData
3D text mesh.
Examples
--------
Create 3D text.
>>> import pyvista as pv
>>> text_mesh = pv.Text3D('PyVista')
>>> text_mesh.plot(cpos='xy', show_bounds=True)
Create planar text.
>>> text_mesh = pv.Text3D('PyVista', depth=0)
>>> text_mesh.plot(cpos='xy', show_bounds=True)
Set the depth explicitly.
>>> text_mesh = pv.Text3D('PyVista', depth=5)
>>> text_mesh.plot(cpos='xy', show_bounds=True)
Set the width explicitly. The height and depth are automatically scaled proportionally.
>>> text_mesh = pv.Text3D('PyVista', width=10)
>>> text_mesh.plot(cpos='xy', show_bounds=True)
Set the height explicitly. The width and depth are automatically scaled proportionally.
>>> text_mesh = pv.Text3D('PyVista', height=10)
>>> text_mesh.plot(cpos='xy', show_bounds=True)
Set the height `and` width. The depth is automatically scaled proportional to height.
>>> text_mesh = pv.Text3D('PyVista', height=10, width=10)
>>> text_mesh.plot(cpos='xy', show_bounds=True)
Set the height, width, and depth independently, and adjust the center.
>>> text_mesh = pv.Text3D(
... 'PyVista', height=10, width=10, depth=0, center=(5, 5, 0)
... )
>>> text_mesh.plot(cpos='xy', show_bounds=True)
See :ref:`create_text_3d_example` for more examples using this function.
pyvista.Text3DSource
Python Library Documentation: class Text3DSource in module pyvista.core.utilities.geometric_sources
class Text3DSource(pyvista.core.utilities.misc._NoNewAttrMixin)
| Text3DSource(*args, **kwargs) -> '_T'
|
| 3D text from a string.
|
| Generate 3D text from a string with a specified width, height or depth.
|
| .. versionadded:: 0.43
|
| .. versionchanged:: 0.48
|
| This class no longer inherits from :vtk:`vtkVectorText`, and uses composition instead.
|
| Parameters
| ----------
| string : str, default: ""
| Text string of the source.
|
| depth : float, optional
| Depth of the text. If ``None``, the depth is set to half
| the :attr:`height` by default. Set to ``0.0`` for planar
| text.
|
| width : float, optional
| Width of the text. If ``None``, the width is scaled
| proportional to :attr:`height`.
|
| height : float, optional
| Height of the text. If ``None``, the height is scaled
| proportional to :attr:`width`.
|
| center : Sequence[float], default: (0.0, 0.0, 0.0)
| Center of the text, defined as the middle of the axis-aligned
| bounding box of the text.
|
| normal : Sequence[float], default: (0.0, 0.0, 1.0)
| Normal direction of the text. The direction is parallel to the
| :attr:`depth` of the text and points away from the front surface
| of the text.
|
| process_empty_string : bool, default: True
| If ``True``, when :attr:`string` is empty the :attr:`output` is a
| single point located at :attr:`center` instead of an empty mesh.
| See :attr:`process_empty_string` for details.
|
| Method resolution order:
| Text3DSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'Text3DSource', string: 'str | None' = None, depth: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), normal: 'VectorLike[float]' = (0.0, 0.0, 1.0), process_empty_string: 'bool' = True) -> 'None'
| Initialize source.
|
| __setattr__(self: 'Text3DSource', name: 'str', value: 'Any') -> 'None'
| Override to set modified flag and disable setting new attributes.
|
| update(self: 'Text3DSource') -> 'None'
| Update the output of the source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output of the source.
|
| The source is automatically updated by :meth:`update` prior
| to returning the output.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Return or set the center of the text.
|
| The center is defined as the middle of the axis-aligned bounding box
| of the text.
|
| depth
| Return or set the depth of the text.
|
| height
| Return or set the height of the text.
|
| normal
| Return or set the normal direction of the text.
|
| The normal direction is parallel to the :attr:`depth` of the text, and
| points away from the front surface of the text.
|
| process_empty_string
| Return or set flag to control behavior when empty strings are set.
|
| When :attr:`string` is empty or only contains whitespace, the :attr:`output`
| mesh will be empty. This can cause the bounds of the output to be undefined.
|
| If ``True``, the output is modified to instead have a single point located
| at :attr:`center`.
|
| string
| Return or set the text string.
|
| width
| Return or set the width of the text.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
pyvista.TimeReader
Python Library Documentation: class TimeReader in module pyvista.core.utilities.reader
class TimeReader(abc.ABC)
| Abstract class for readers supporting time.
|
| Method resolution order:
| TimeReader
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| set_active_time_point(self, time_point)
| Set active time or iteration by index.
|
| Parameters
| ----------
| time_point : int
| Time or iteration point index for setting active time.
|
| set_active_time_value(self, time_value)
| Set active time or iteration value.
|
| Parameters
| ----------
| time_value : float
| Time or iteration value to set as active.
|
| time_point_value(self, time_point)
| Value of time point or iteration by index.
|
| Parameters
| ----------
| time_point : int
| Time point index.
|
| Returns
| -------
| float
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| active_time_value
| Active time or iteration value.
|
| Returns
| -------
| float
|
| number_time_points
| Return number of time points or iterations available to read.
|
| Returns
| -------
| int
|
| time_values
| All time or iteration values.
|
| Returns
| -------
| list[float]
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'active_time_value', 'number_time_poi...
|
| __annotations__ = {}
pyvista.Transform
Python Library Documentation: class Transform in module pyvista.core.utilities.transform
class Transform(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride, vtkmodules.vtkCommonTransforms.vtkTransform)
| Transform(*args, **kwargs) -> '_T'
|
| Describes linear transformations via a 4x4 matrix.
|
| A :class:`Transform` can be used to describe the full range of linear (also known
| as affine) coordinate transformations in three dimensions, which are internally
| represented as a 4x4 homogeneous transformation matrix.
|
| The transformation methods (e.g. :meth:`translate`, :meth:`rotate`,
| :meth:`compose`) can operate in either :meth:`pre_multiply` or
| :meth:`post_multiply` mode. In pre-multiply mode, any additional transformations
| will occur *before* any transformations represented by the current :attr:`matrix`.
| In post-multiply mode (the default), the additional transformation will occur
| *after* any transformations represented by the current matrix.
|
| .. note::
|
| This class performs all of its operations in a right-handed coordinate system
| with right-handed rotations. Some other graphics libraries use left-handed
| coordinate systems and rotations.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| trans : TransformLike | Sequence[TransformLike], optional
| Initialize the transform with a transformation or sequence of transformations.
| By default, the transform is initialized as the identity matrix.
|
| point : VectorLike[float], optional
| Point to use when composing transformations.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the transformation
| - :meth:`translate` away from ``point`` after the transformation
|
| By default, this value is ``None``, which means that the scale, rotation, etc.
| transformations are performed about the origin ``(0, 0, 0)``.
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing. Set this to ``'pre'`` for
| pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| pyvista.DataObjectFilters.transform
| Apply a transformation to a mesh.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Create a transformation and use ``+`` to compose a translation.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> position = (-0.6, -0.8, 2.1)
| >>> translation_T = pv.Transform() + position
| >>> translation_T.matrix
| array([[ 1. , 0. , 0. , -0.6],
| [ 0. , 1. , 0. , -0.8],
| [ 0. , 0. , 1. , 2.1],
| [ 0. , 0. , 0. , 1. ]])
|
| Using ``+`` performs the same concatenation as calling :meth:`translate`.
|
| >>> np.array_equal(
| ... translation_T.matrix, pv.Transform().translate(position).matrix
| ... )
| True
|
| Create a transformation and use ``*`` to compose a scaling matrix.
|
| >>> scale_factor = 2.0
| >>> scaling_T = pv.Transform() * scale_factor
| >>> scaling_T.matrix
| array([[2., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 2., 0.],
| [0., 0., 0., 1.]])
|
| Using ``*`` performs the same concatenation as calling :meth:`scale`.
|
| >>> np.array_equal(scaling_T.matrix, pv.Transform().scale(scale_factor).matrix)
| True
|
| Compose the two transformations using ``*``. This will compose with
| post-multiplication such that the transformations are applied in order from left to
| right, i.e. translate first, then scale.
|
| >>> transform_post = translation_T * scaling_T
| >>> transform_post.matrix
| array([[ 2. , 0. , 0. , -1.2],
| [ 0. , 2. , 0. , -1.6],
| [ 0. , 0. , 2. , 4.2],
| [ 0. , 0. , 0. , 1. ]])
|
| Post-multiplication is equivalent to using matrix multiplication on the
| arrays directly but with the arguments reversed:
|
| >>> mat_mul = scaling_T.matrix @ translation_T.matrix
| >>> np.array_equal(transform_post.matrix, mat_mul)
| True
|
| Alternatively, compose the transformations by chaining the methods with a
| single :class:`Transform` instance. Note that post-multiply is used by default.
|
| >>> transform_post = pv.Transform()
| >>> transform_post.multiply_mode
| 'post'
| >>> _ = transform_post.translate(position).scale(scale_factor)
| >>> transform_post.matrix
| array([[ 2. , 0. , 0. , -1.2],
| [ 0. , 2. , 0. , -1.6],
| [ 0. , 0. , 2. , 4.2],
| [ 0. , 0. , 0. , 1. ]])
|
| Use :attr:`n_transformations` to check that there are two transformations.
|
| >>> transform_post.n_transformations
| 2
|
| Use :attr:`matrix_list` to get a list of the transformations. Since
| post-multiplication is used, the translation matrix is first in the list since
| it was applied first, and the scale matrix is second.
|
| >>> transform_post.matrix_list[0] # translation
| array([[ 1. , 0. , 0. , -0.6],
| [ 0. , 1. , 0. , -0.8],
| [ 0. , 0. , 1. , 2.1],
| [ 0. , 0. , 0. , 1. ]])
|
| >>> transform_post.matrix_list[1] # scaling
| array([[2., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 2., 0.],
| [0., 0., 0., 1.]])
|
| Create a similar transform but use pre-multiplication this time. Compose the
| transformations in the same order as before using :meth:`translate` and :meth:`scale`.
|
| >>> transform_pre = pv.Transform().pre_multiply()
| >>> _ = transform_pre.translate(position).scale(scale_factor)
|
| This is equivalent to using matrix multiplication directly on the arrays:
|
| >>> mat_mul = translation_T.matrix @ scaling_T.matrix
| >>> np.array_equal(transform_pre.matrix, mat_mul)
| True
|
| Show the matrix list again. Note how the order with pre-multiplication is the
| reverse of post-multiplication.
|
| >>> transform_pre.matrix_list[0] # scaling
| array([[2., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 2., 0.],
| [0., 0., 0., 1.]])
|
| >>> transform_pre.matrix_list[1] # translation
| array([[ 1. , 0. , 0. , -0.6],
| [ 0. , 1. , 0. , -0.8],
| [ 0. , 0. , 1. , 2.1],
| [ 0. , 0. , 0. , 1. ]])
|
| Apply the two post- and pre-multiplied transformations to a dataset and plot them.
| Note how the meshes have different positions since post- and pre-multiplication
| produce different transformations.
|
| >>> mesh_post = pv.Sphere().transform(transform_post, inplace=False)
| >>> mesh_pre = pv.Cone().transform(transform_pre, inplace=False)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh_post, color='goldenrod')
| >>> _ = pl.add_mesh(mesh_pre, color='teal')
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| Get the composed inverse transformation matrix of the pre-multiplication case.
|
| >>> inverse_matrix = transform_pre.inverse_matrix
| >>> inverse_matrix
| array([[ 0.5 , 0. , 0. , 0.3 ],
| [ 0. , 0.5 , 0. , 0.4 ],
| [ 0. , 0. , 0.5 , -1.05],
| [ 0. , 0. , 0. , 1. ]])
|
| Similar to using :attr:`matrix_list`, we can inspect the individual transformation
| inverses with :attr:`inverse_matrix_list`.
|
| >>> transform_pre.inverse_matrix_list[0] # inverse scaling
| array([[0.5, 0. , 0. , 0. ],
| [0. , 0.5, 0. , 0. ],
| [0. , 0. , 0.5, 0. ],
| [0. , 0. , 0. , 1. ]])
|
| >>> transform_pre.inverse_matrix_list[1] # inverse translation
| array([[ 1. , 0. , 0. , 0.6],
| [ 0. , 1. , 0. , 0.8],
| [ 0. , 0. , 1. , -2.1],
| [ 0. , 0. , 0. , 1. ]])
|
| Transform the mesh by its inverse to restore it to its original un-scaled state
| and positioning at the origin.
|
| >>> mesh_pre_inverted = mesh_pre.transform(inverse_matrix, inplace=False)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh_pre_inverted, color='teal')
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| Method resolution order:
| Transform
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonTransforms.vtkTransform
| vtkmodules.vtkCommonTransforms.vtkLinearTransform
| vtkmodules.vtkCommonTransforms.vtkHomogeneousTransform
| vtkmodules.vtkCommonTransforms.vtkAbstractTransform
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __add__(self: 'Transform', other: 'VectorLike[float]') -> 'Transform'
| :meth:`translate` this transform using post-multiply semantics.
|
| __init__(self: 'Transform', trans: 'TransformLike | Sequence[TransformLike] | None' = None, *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post']" = 'post') -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __mul__(self: 'Transform', other: 'float | VectorLike[float] | TransformLike') -> 'Transform'
| :meth:`compose` this transform using post-multiply semantics.
|
| Use :meth:`scale` for single numbers and length-3 vector inputs, and
| :meth:`compose` otherwise for transform-like inputs.
|
| __radd__(self: 'Transform', other: 'VectorLike[float]') -> 'Transform'
| :meth:`translate` this transform using pre-multiply semantics.
|
| __repr__(self: 'Transform') -> 'str'
| Representation of the transform.
|
| __rmul__(self: 'Transform', other: 'float | VectorLike[float]') -> 'Transform'
| :meth:`scale` this transform using pre-multiply semantics.
|
| apply(self: 'Transform', obj: 'VectorLike[float] | MatrixLike[float] | DataSet | MultiBlock | Prop3D', /, mode: "Literal['points', 'vectors', 'active_vectors', 'all_vectors', 'replace', 'pre-multiply', 'post-multiply'] | None" = None, *, inverse: 'bool' = False, copy: 'bool' = True)
| Apply the current transformation :attr:`~Transform.matrix` to points, vectors, a dataset, or actor.
|
| .. note::
|
| Points with integer values are cast to a float type before the
| transformation is applied. A similar casting is also performed when
| transforming datasets. See also the notes at
| :func:`~pyvista.DataObjectFilters.transform`
| which is used by this filter under the hood.
|
| Parameters
| ----------
| obj : VectorLike[float] | MatrixLike[float] | DataSet | MultiBlock | Prop3D
| Object to apply the transformation to.
|
| mode : str, optional
| Define how to apply the transformation. Different modes may be used depending
| on the input type.
|
| #. For array inputs:
|
| - ``'points'`` transforms point arrays.
| - ``'vectors'`` transforms vector arrays. The translation component of
| the transformation is removed for vectors.
|
| By default, ``'points'`` mode is used for array inputs.
|
| #. For dataset inputs:
|
| The dataset's points are always transformed, and its vectors are
| transformed based on the mode:
|
| - ``'active_vectors'`` transforms active normals and active vectors
| arrays only.
| - ``'all_vectors'`` transforms `all` input vectors, i.e. all arrays
| with three components. This mode is equivalent to setting
| ``transform_all_input_vectors=True``
| with :meth:`pyvista.DataObjectFilters.transform`.
|
| By default, only ``'active_vectors'`` are transformed.
|
| #. For actor inputs:
|
| - ``'pre-multiply'`` pre-multiplies this transform with the actor's
| :attr:`~pyvista.Prop3D.user_matrix`.
| - ``'post-multiply'`` post-multiplies this transform with the actor's
| user-matrix.
| - ``'replace'`` replaces the actor's user-matrix with this transform's
| :attr:`matrix`.
|
| By default, ``'post-multiply'`` mode is used for actors.
|
| inverse : bool, default: False
| Apply the transformation using the :attr:`inverse_matrix` instead of the
| :attr:`matrix`.
|
| copy : bool, default: True
| Return a copy of the input with the transformation applied. Set this to
| ``False`` to transform the input directly and return it. Setting this to
| ``False`` only applies to NumPy float arrays, datasets, and actors; a copy
| is always returned for tuple and list inputs or arrays with integers.
|
| Returns
| -------
| output : np.ndarray | DataSet | MultiBlock | Prop3D
| Transformed array, dataset, or actor.
|
| See Also
| --------
| apply_to_points
| Equivalent to ``apply(obj, 'points')`` for point-array inputs.
| apply_to_vectors
| Equivalent to ``apply(obj, 'vectors')`` for vector-array inputs.
| apply_to_dataset
| Equivalent to ``apply(obj, mode)`` for dataset inputs where ``mode`` may be
| ``'active_vectors'`` or ``'all_vectors'``.
| apply_to_actor
| Equivalent to ``apply(obj, mode)`` for actor inputs where ``mode`` may be
| ``'pre-multiply'``, ``'post-multiply'``, or ``'replace'``.
| pyvista.DataObjectFilters.transform
| Transform a dataset.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Apply a transformation to a point.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> point = (1.0, 2.0, 3.0)
| >>> transform = pv.Transform().scale(2).translate((0.0, 0.0, 1.0))
| >>> transformed = transform.apply(point)
| >>> transformed
| array([2., 4., 7.])
|
| Apply a transformation to a points array.
|
| >>> array = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
| >>> transformed = transform.apply(array)
| >>> transformed
| array([[ 2., 4., 7.],
| [ 8., 10., 13.]])
|
| Apply a transformation to a vector array. Use the same array as before but
| use the ``'vectors'`` mode. Note how the translation component is not applied
| to vectors.
|
| >>> transformed = transform.apply(array, 'vectors')
| >>> transformed
| array([[ 2., 4., 6.],
| [ 8., 10., 12.]])
|
| Apply a transformation to a dataset.
|
| >>> dataset = pv.PolyData(array)
| >>> transformed = transform.apply(dataset)
| >>> transformed.points
| pyvista_ndarray([[ 2., 4., 6.],
| [ 8., 10., 12.]])
|
| Apply the inverse.
|
| >>> transformed = transform.apply(dataset, inverse=True)
| >>> transformed.points
| pyvista_ndarray([[0.5, 1. , 1. ],
| [2. , 2.5, 2.5]])
|
| Apply a transformation to an actor.
|
| >>> actor = pv.Actor()
| >>> transformed_actor = transform.apply(actor)
| >>> transformed_actor.user_matrix
| array([[2., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 2., 0.],
| [0., 0., 0., 1.]])
|
| apply_to_actor(self, actor: 'Prop3D', /, mode: "Literal['pre-multiply', 'post-multiply', 'replace']" = 'post-multiply', *, copy: 'bool' = True, inverse: 'bool' = False) -> 'Prop3D'
| Apply the current transformation :attr:`~Transform.matrix` to an actor.
|
| This is equivalent to ``apply(actor, mode)``. See :meth:`apply` for details and
| examples.
|
| Parameters
| ----------
| actor : Prop3D
| Actor to apply the transformation to.
|
| mode : 'pre-multiply', 'post-multiply', 'replace', default: 'post-multiply'
| Mode for transforming the actor:
|
| - ``'pre-multiply'`` pre-multiplies this transform with the actor's
| :attr:`~pyvista.Prop3D.user_matrix`.
| - ``'post-multiply'`` post-multiplies this transform with the actor's
| user-matrix.
| - ``'replace'`` replaces the actor's user-matrix with this transform's
| :attr:`matrix`.
|
| By default, ``'post-multiply'`` mode is used.
|
| inverse : bool, default: False
| Apply the transformation using the :attr:`inverse_matrix` instead of the
| :attr:`matrix`.
|
| copy : bool, default: True
| Return a copy of the input with the transformation applied. Set this to
| ``False`` to transform the input directly and return it.
|
| Returns
| -------
| Prop3D
| Transformed actor.
|
| See Also
| --------
| apply
| Apply this transformation to any input.
| apply_to_points
| Apply this transformation to points.
| apply_to_vectors
| Apply this transformation to vectors.
| apply_to_dataset
| Apply this transformation to a dataset.
| pyvista.Prop3D.transform
| Transform an actor.
|
| apply_to_dataset(self, dataset: '_DataSetOrMultiBlockType', /, mode: "Literal['active_vectors', 'all_vectors']" = 'active_vectors', *, copy: 'bool' = True, inverse: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Apply the current transformation :attr:`~Transform.matrix` to a dataset.
|
| This is equivalent to ``apply(dataset, mode)``. See :meth:`apply` for details
| and examples.
|
| Parameters
| ----------
| dataset : DataSet | MultiBlock
| Object to apply the transformation to.
|
| mode : 'active_vectors' | 'all_vectors', default: 'active_vectors'
| Mode for transforming the dataset's vectors:
|
| - ``'active_vectors'`` transforms active normals and active vectors arrays
| only.
| - ``'all_vectors'`` transforms `all` input vectors, i.e. all arrays with
| three components. This mode is equivalent to setting
| ``transform_all_input_vectors=True``
| with :meth:`pyvista.DataObjectFilters.transform`.
|
| inverse : bool, default: False
| Apply the transformation using the :attr:`inverse_matrix` instead of the
| :attr:`matrix`.
|
| copy : bool, default: True
| Return a copy of the input with the transformation applied. Set this to
| ``False`` to transform the input directly and return it.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset.
|
| See Also
| --------
| apply
| Apply this transformation to any input.
| apply_to_points
| Apply this transformation to points.
| apply_to_vectors
| Apply this transformation to vectors.
| apply_to_actor
| Apply this transformation to an actor.
| pyvista.DataObjectFilters.transform
| Transform a dataset.
|
| apply_to_points(self, points: 'VectorLike[float] | MatrixLike[float]', /, *, inverse: 'bool' = False, copy: 'bool' = True) -> 'NumpyArray[float]'
| Apply the current transformation :attr:`~Transform.matrix` to a point or points.
|
| This is equivalent to ``apply(points, 'points')``. See :meth:`apply` for
| details and examples.
|
| Parameters
| ----------
| points : VectorLike[float] | MatrixLike[float]
| Single point or ``Nx3`` points array to apply the transformation to.
|
| inverse : bool, default: False
| Apply the transformation using the :attr:`inverse_matrix` instead of the
| :attr:`matrix`.
|
| copy : bool, default: True
| Return a copy of the input with the transformation applied. Set this to
| ``False`` to transform the input directly and return it. Only applies to
| NumPy arrays. A copy is always returned for tuple and list
| inputs or point arrays with integers.
|
| Returns
| -------
| np.ndarray
| Transformed points.
|
| See Also
| --------
| apply
| Apply this transformation to any input.
| apply_to_vectors
| Apply this transformation to vectors.
| apply_to_dataset
| Apply this transformation to a dataset.
| apply_to_actor
| Apply this transformation to an actor.
|
| apply_to_vectors(self, vectors: 'VectorLike[float] | MatrixLike[float]', /, *, inverse: 'bool' = False, copy: 'bool' = True) -> 'NumpyArray[float]'
| Apply the current transformation :attr:`~Transform.matrix` to a vector or vectors.
|
| This is equivalent to ``apply(vectors, 'vectors')``. See :meth:`apply` for
| details and examples.
|
| Parameters
| ----------
| vectors : VectorLike[float] | MatrixLike[float]
| Single vector or ``Nx3`` vectors array to apply the transformation to.
|
| inverse : bool, default: False
| Apply the transformation using the :attr:`inverse_matrix` instead of the
| :attr:`matrix`.
|
| copy : bool, default: True
| Return a copy of the input with the transformation applied. Set this to
| ``False`` to transform the input directly and return it. Only applies to
| NumPy arrays. A copy is always returned for tuple and list
| inputs or point arrays with integers.
|
| Returns
| -------
| np.ndarray
| Transformed vectors.
|
| See Also
| --------
| apply
| Apply this transformation to any input.
| apply_to_points
| Apply this transformation to points.
| apply_to_dataset
| Apply this transformation to a dataset.
| apply_to_actor
| Apply this transformation to an actor.
|
| as_rotation(self, representation: "Literal['quat', 'matrix', 'rotvec', 'mrp', 'euler', 'davenport'] | None" = None, *args, **kwargs) -> 'Rotation | NumpyArray[float]'
| Return the rotation component as a SciPy ``Rotation`` or any of its representations.
|
| The current :attr:`matrix` is first decomposed to extract the rotation component
| and then returned with the specified representation.
|
| .. note::
|
| This method depends on the ``scipy`` package which must be installed to use it.
|
| Parameters
| ----------
| representation : str, optional
| Representation of the rotation.
|
| - ``'quat'``: Represent as a quaternion using
| :meth:`~scipy.spatial.transform.Rotation.as_quat`. Returns a length-4 vector.
| - ``'matrix'``: Represent as a 3x3 matrix using
| :meth:`~scipy.spatial.transform.Rotation.as_matrix`.
| - ``'rotvec'``: Represent as a rotation vector using
| :meth:`~scipy.spatial.transform.Rotation.as_rotvec`.
| - ``'mrp'``: Represent as a Modified Rodrigues Parameters (MRPs) vector using
| :meth:`~scipy.spatial.transform.Rotation.as_mrp`.
| - ``'euler'``: Represent as Euler angles using
| :meth:`~scipy.spatial.transform.Rotation.as_euler`.
| - ``'davenport'``: Represent as Davenport angles using
| :meth:`~scipy.spatial.transform.Rotation.as_davenport`.
|
| If no representation is given, then an instance of
| :class:`scipy.spatial.transform.Rotation` is returned by default.
|
| *args
| Arguments passed to the ``Rotation`` method for the specified
| representation.
|
| **kwargs
| Keyword arguments passed to the ``Rotation`` method for the specified
| representation.
|
| Returns
| -------
| output : scipy.spatial.transform.Rotation | np.ndarray
| Rotation object or array depending on the representation.
|
| See Also
| --------
| rotation_matrix, rotation_axis_angle, decompose
| Get this transform's rotation component `without` using SciPy.
| rotate, rotate_x, rotate_y, rotate_z, rotate_vector
| Compose a rotation matrix.
|
| Examples
| --------
| Create a rotation matrix and initialize a :class:`Transform` from it.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> matrix = [[0, -1, 0], [1, 0, 0], [0, 0, 1]]
| >>> transform = pv.Transform(matrix)
|
| Represent the rotation as :class:`scipy.spatial.transform.Rotation` instance.
|
| >>> rot = transform.as_rotation()
| >>> type(rot)
| <class 'scipy.spatial.transform._rotation.Rotation'>
|
| Represent the rotation as a quaternion.
|
| >>> rot = transform.as_rotation('quat')
| >>> rot
| array([0. , 0. , 0.70710678, 0.70710678])
|
| Represent the rotation as a rotation vector. The vector has a direction
| ``(0, 0, 1)`` and magnitude of ``pi/2``.
|
| >>> rot = transform.as_rotation('rotvec')
| >>> rot
| array([0. , 0. , 1.57079633])
|
| Represent the rotation as a Modified Rodrigues Parameters vector.
|
| >>> rot = transform.as_rotation('mrp')
| >>> rot
| array([0. , 0. , 0.41421356])
|
| Represent the rotation as x-y-z Euler angles in degrees.
|
| >>> rot = transform.as_rotation('euler', 'xyz', degrees=True)
| >>> rot
| array([ 0., 0., 90.])
|
| Represent the rotation as extrinsic x-y-z Davenport angles in degrees.
|
| >>> rot = transform.as_rotation(
| ... 'davenport', np.eye(3), 'extrinsic', degrees=True
| ... )
| >>> rot
| array([-1.27222187e-14, 0.00000000e+00, 9.00000000e+01])
|
| compose(self: 'Transform', transform: 'TransformLike', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a transformation matrix.
|
| Create a 4x4 matrix from any transform-like input and compose it with the
| current transformation :attr:`matrix` according to pre-multiply or post-multiply
| semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| transform : TransformLike
| Any transform-like input such as a 3x3 or 4x4 array or matrix.
|
| point : VectorLike[float], optional
| Point to transform about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the transformation
| - :meth:`translate` away from ``point`` after the transformation
|
| .. versionadded:: 0.47
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| decompose
|
| Examples
| --------
| Define an arbitrary 4x4 affine transformation matrix and compose it.
|
| >>> import pyvista as pv
| >>> array = [
| ... [0.707, -0.707, 0, 0],
| ... [0.707, 0.707, 0, 0],
| ... [0, 0, 1, 1.5],
| ... [0, 0, 0, 2],
| ... ]
| >>> transform = pv.Transform().compose(array)
| >>> transform.matrix
| array([[ 0.707, -0.707, 0. , 0. ],
| [ 0.707, 0.707, 0. , 0. ],
| [ 0. , 0. , 1. , 1.5 ],
| [ 0. , 0. , 0. , 2. ]])
|
| Define a second transformation and use ``*`` to compose it.
|
| >>> array = [[1, 0, 0], [0, 0, -1], [0, -1, 0]]
| >>> transform = transform * array
| >>> transform.matrix
| array([[ 0.707, -0.707, 0. , 0. ],
| [ 0. , 0. , -1. , -1.5 ],
| [-0.707, -0.707, 0. , 0. ],
| [ 0. , 0. , 0. , 2. ]])
|
| Compose the transform about a point. Check the :attr:`matrix_list` to see that a
| translation is added before and after the transform.
|
| >>> transform = pv.Transform().compose(transform, point=(1, 2, 3))
| >>> transform.matrix_list # doctest: +NORMALIZE_WHITESPACE
| [array([[ 1., 0., 0., -1.],
| [ 0., 1., 0., -2.],
| [ 0., 0., 1., -3.],
| [ 0., 0., 0., 1.]]),
| array([[ 0.707, -0.707, 0. , 0. ],
| [ 0. , 0. , -1. , -1.5 ],
| [-0.707, -0.707, 0. , 0. ],
| [ 0. , 0. , 0. , 2. ]]),
| array([[1., 0., 0., 1.],
| [0., 1., 0., 2.],
| [0., 0., 1., 3.],
| [0., 0., 0., 1.]])]
|
| copy(self: 'Transform') -> 'Transform'
| Return a deep copy of the transform.
|
| Returns
| -------
| Transform
| Deep copy of this transform.
|
| Examples
| --------
| Create a scaling transform.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().scale(1, 2, 3)
| >>> transform.matrix
| array([[1., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 3., 0.],
| [0., 0., 0., 1.]])
|
| Copy the transform.
|
| >>> copied = transform.copy()
| >>> copied.matrix
| array([[1., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 3., 0.],
| [0., 0., 0., 1.]])
|
| >>> copied is transform
| False
|
| decompose(self: 'Transform', *, homogeneous: 'bool' = False) -> '_FiveArrays'
| Decompose the current transformation into its components.
|
| Decompose the :attr:`matrix` ``M`` into
|
| - translation ``T``
| - rotation ``R``
| - reflection ``N``
| - scaling ``S``
| - shearing ``K``
|
| such that, when represented as 4x4 matrices, ``M = TRNSK``. The decomposition is
| unique and is computed with polar matrix decomposition.
|
| By default, compact representations of the transformations are returned (e.g. as a
| 3-element vector or a 3x3 matrix). Optionally, 4x4 matrices may be returned instead.
|
| .. note::
|
| - The rotation is orthonormal and right-handed with positive determinant.
| - The scaling factors are positive.
| - The reflection is either ``1`` (no reflection) or ``-1`` (has reflection)
| and can be used like a scaling factor.
|
| Parameters
| ----------
| homogeneous : bool, default: False
| If ``True``, return the components (translation, rotation, etc.) as 4x4
| homogeneous matrices. By default, reflection is a scalar, translation and
| scaling are length-3 vectors, and rotation and shear are 3x3 matrices.
|
| Returns
| -------
| numpy.ndarray
| Translation component ``T``. Returned as a 3-element vector (or a 4x4
| translation matrix if ``homogeneous`` is ``True``).
|
| numpy.ndarray
| Rotation component ``R``. Returned as a 3x3 orthonormal rotation matrix of row
| vectors (or a 4x4 rotation matrix if ``homogeneous`` is ``True``).
|
| numpy.ndarray
| Reflection component ``N``. Returned as a NumPy scalar (or a 4x4 reflection
| matrix if ``homogeneous`` is ``True``).
|
| numpy.ndarray
| Scaling component ``S``. Returned as a 3-element vector (or a 4x4 scaling matrix
| if ``homogeneous`` is ``True``).
|
| numpy.ndarray
| Shear component ``K``. Returned as a 3x3 matrix with ones on the diagonal and
| shear values in the off-diagonals (or as a 4x4 shearing matrix if ``homogeneous``
| is ``True``).
|
| See Also
| --------
| compose
| Compose a transformation.
|
| translation, has_translation
| Get info about this transform's translation component.
|
| rotation_matrix, rotation_axis_angle, as_rotation, has_rotation
| Get info about this transform's rotation component.
|
| reflection, has_reflection
| Get info about this transform's reflection component.
|
| scale_factors, has_scale
| Get info about this transform's scale component.
|
| shear_matrix, has_shear
| Get info about this transform's shear component.
|
| Examples
| --------
| Create a transform by composing scaling, rotation, and translation
| matrices.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> transform = pv.Transform()
| >>> _ = transform.scale(1, 2, 3)
| >>> _ = transform.rotate_z(90)
| >>> _ = transform.translate(4, 5, 6)
| >>> transform
| Transform (...)
| Num Transformations: 3
| Matrix: [[ 0., -2., 0., 4.],
| [ 1., 0., 0., 5.],
| [ 0., 0., 3., 6.],
| [ 0., 0., 0., 1.]]
|
| Decompose the matrix.
|
| >>> T, R, N, S, K = transform.decompose()
|
| Since the input has no shear this component is the identity matrix.
| Similarly, there are no reflections so its value is ``1``. All other components
| are recovered perfectly and match the input.
|
| >>> K # shear
| array([[1., 0., 0.],
| [0., 1., 0.],
| [0., 0., 1.]])
|
| >>> S # scale
| array([1., 2., 3.])
|
| >>> N # reflection
| array(1.)
|
| >>> R # rotation
| array([[ 0., -1., 0.],
| [ 1., 0., 0.],
| [ 0., 0., 1.]])
|
| >>> T # translation
| array([4., 5., 6.])
|
| Compose a shear component using pre-multiplication so that shearing is
| the first transformation.
|
| >>> shear = np.eye(4)
| >>> shear[0, 1] = 0.1 # xy shear
| >>> _ = transform.compose(shear, multiply_mode='pre')
|
| Repeat the decomposition and show its components. Note how the decomposed shear
| does not perfectly match the input shear matrix values. The values of the
| scaling and rotation components are also affected and do not exactly match the
| input. This is expected, because the shear can be partially factored as a
| combination of rotation and scaling.
|
| >>> T, R, N, S, K = transform.decompose()
|
| >>> K # shear
| array([[1. , 0.03333333, 0. ],
| [0.01663894, 1. , 0. ],
| [0. , 0. , 1. ]])
|
| >>> S # scale
| array([0.99944491, 2.0022213 , 3. ])
|
| >>> N # reflection
| array(1.)
|
| >>> R # rotation
| array([[ 0.03331483, -0.99944491, 0. ],
| [ 0.99944491, 0.03331483, 0. ],
| [ 0. , 0. , 1. ]])
|
| >>> T # translation
| array([4., 5., 6.])
|
| Although the values may not match the input exactly, the decomposition is
| nevertheless valid and can be used to re-compose the original transformation.
|
| >>> T, R, N, S, K = transform.decompose(homogeneous=True)
| >>> T @ R @ N @ S @ K
| array([[-5.76153045e-17, -2.00000000e+00, 0.00000000e+00,
| 4.00000000e+00],
| [ 1.00000000e+00, 1.00000000e-01, 0.00000000e+00,
| 5.00000000e+00],
| [ 0.00000000e+00, 0.00000000e+00, 3.00000000e+00,
| 6.00000000e+00],
| [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
| 1.00000000e+00]])
|
| Alternatively, re-compose the transformation as a new
| :class:`~pyvista.Transform` with pre-multiplication.
|
| >>> recomposed = pv.Transform([T, R, N, S, K], multiply_mode='pre')
| >>> np.allclose(recomposed.matrix, transform.matrix)
| True
|
| Compose a reflection and decompose the transform again.
|
| >>> _ = transform.flip_x()
| >>> T, R, N, S, K = transform.decompose()
|
| The reflection component is now ``-1``.
|
| >>> N # reflection
| array(-1.)
|
| The decomposition may be simplified to a ``TRSK`` decomposition by combining
| the reflection component with either the rotation or the scaling term.
|
| Multiplying the reflection with the rotation will make it a left-handed rotation
| with negative determinant:
|
| >>> R = R * N
| >>> np.linalg.det(R) < 0
| np.True_
|
| Alternatively, keep the rotation right-handed but make the scaling factors negative:
|
| >>> S = S * N
| >>> S # scale
| array([-0.99944491, -2.0022213 , -3. ])
|
| flip_x(self: 'Transform', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a reflection about the x-axis.
|
| Create a reflection about the x-axis and :meth:`compose` it
| with the current transformation :attr:`matrix` according to pre-multiply or
| post-multiply semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to reflect about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the reflection
| - :meth:`translate` away from ``point`` after the reflection
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| reflect, flip_y, flip_z
| Similar reflection methods.
|
| pyvista.DataObjectFilters.flip_x
| Flip a mesh about the x-axis.
|
| reflection, has_reflection
| Get info about the transform's reflection component.
|
| Examples
| --------
| Compose a reflection about the x-axis.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform()
| >>> _ = transform.flip_x()
| >>> transform.matrix
| array([[-1., 0., 0., 0.],
| [ 0., 1., 0., 0.],
| [ 0., 0., 1., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second reflection, but this time about a point.
|
| >>> _ = transform.flip_x(point=(4, 5, 6))
| >>> transform.matrix
| array([[1., 0., 0., 8.],
| [0., 1., 0., 0.],
| [0., 0., 1., 0.],
| [0., 0., 0., 1.]])
|
| flip_y(self: 'Transform', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a reflection about the y-axis.
|
| Create a reflection about the y-axis and :meth:`compose` it
| with the current transformation :attr:`matrix` according to pre-multiply or
| post-multiply semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to reflect about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the reflection
| - :meth:`translate` away from ``point`` after the reflection
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| reflect, flip_x, flip_z
| Similar reflection methods.
|
| pyvista.DataObjectFilters.flip_y
| Flip a mesh about the y-axis.
|
| reflection, has_reflection
| Get info about the transform's reflection component.
|
| Examples
| --------
| Compose a reflection about the y-axis.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform()
| >>> _ = transform.flip_y()
| >>> transform.matrix
| array([[ 1., 0., 0., 0.],
| [ 0., -1., 0., 0.],
| [ 0., 0., 1., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second reflection, but this time about a point.
|
| >>> _ = transform.flip_y(point=(4, 5, 6))
| >>> transform.matrix
| array([[ 1., 0., 0., 0.],
| [ 0., 1., 0., 10.],
| [ 0., 0., 1., 0.],
| [ 0., 0., 0., 1.]])
|
| flip_z(self: 'Transform', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a reflection about the z-axis.
|
| Create a reflection about the z-axis and :meth:`compose` it
| with the current transformation :attr:`matrix` according to pre-multiply or
| post-multiply semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to reflect about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the reflection
| - :meth:`translate` away from ``point`` after the reflection
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| reflect, flip_x, flip_y
| Similar reflection methods.
|
| pyvista.DataObjectFilters.flip_z
| Flip a mesh about the z-axis.
|
| reflection, has_reflection
| Get info about the transform's reflection component.
|
| Examples
| --------
| Compose a reflection about the z-axis.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform()
| >>> _ = transform.flip_z()
| >>> transform.matrix
| array([[ 1., 0., 0., 0.],
| [ 0., 1., 0., 0.],
| [ 0., 0., -1., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second reflection, but this time about a point.
|
| >>> _ = transform.flip_z(point=(4, 5, 6))
| >>> transform.matrix
| array([[ 1., 0., 0., 0.],
| [ 0., 1., 0., 0.],
| [ 0., 0., 1., 12.],
| [ 0., 0., 0., 1.]])
|
| identity(self: 'Transform') -> 'Transform'
| Set the transformation to the identity transformation.
|
| This can be used to "reset" the transform.
|
| Examples
| --------
| Compose an arbitrary transformation.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().scale(2.0)
| >>> transform.matrix
| array([[2., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 2., 0.],
| [0., 0., 0., 1.]])
|
| Reset the transformation to the identity matrix.
|
| >>> _ = transform.identity()
| >>> transform.matrix
| array([[1., 0., 0., 0.],
| [0., 1., 0., 0.],
| [0., 0., 1., 0.],
| [0., 0., 0., 1.]])
|
| invert(self: 'Transform') -> 'Transform'
| Invert the current transformation.
|
| The current transformation :attr:`matrix` (including all matrices in the
| :attr:`matrix_list`) is inverted every time :meth:`invert` is called.
|
| Use :attr:`is_inverted` to check if the transformations are currently inverted.
|
| Examples
| --------
| Compose an arbitrary transformation.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().scale(2.0)
| >>> transform.matrix
| array([[2., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 2., 0.],
| [0., 0., 0., 1.]])
|
| Check if the transformation is inverted.
|
| >>> transform.is_inverted
| False
|
| Invert the transformation and show the matrix.
|
| >>> _ = transform.invert()
| >>> transform.matrix
| array([[0.5, 0. , 0. , 0. ],
| [0. , 0.5, 0. , 0. ],
| [0. , 0. , 0.5, 0. ],
| [0. , 0. , 0. , 1. ]])
|
| Check that the transformation is inverted.
|
| >>> transform.is_inverted
| True
|
| Invert it again to restore it back to its original state.
|
| >>> _ = transform.invert()
| >>> transform.matrix
| array([[2., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 2., 0.],
| [0., 0., 0., 1.]])
| >>> transform.is_inverted
| False
|
| post_multiply(self: 'Transform') -> 'Transform'
| Set the multiplication mode to post-multiply.
|
| In post-multiply mode, any additional transformations (e.g. using
| :meth:`translate`, :meth:`compose`, etc.) will occur *after* any
| transformations represented by the current :attr:`matrix`.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> transform = pv.Transform().post_multiply()
| >>> transform.multiply_mode
| 'post'
|
| pre_multiply(self: 'Transform') -> 'Transform'
| Set the multiplication mode to pre-multiply.
|
| In pre-multiply mode, any additional transformations (e.g. using
| :meth:`translate`, :meth:`compose`, etc.) will occur *before* any
| transformations represented by the current :attr:`matrix`.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> transform = pv.Transform().pre_multiply()
| >>> transform.multiply_mode
| 'pre'
|
| reflect(self: 'Transform', *normal: 'float | VectorLike[float]', point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a reflection matrix.
|
| Create a reflection matrix and :meth:`compose` it with the current
| transformation :attr:`matrix` according to pre-multiply or post-multiply
| semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| *normal : float | VectorLike[float]
| Normal direction for reflection. May be a single vector (one arg) or
| unpacked vector (three args).
|
| point : VectorLike[float], optional
| Point to reflect about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the reflection
| - :meth:`translate` away from ``point`` after the reflection
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| flip_x, flip_y, flip_z
| Convenience methods for reflecting about the x-, y-, or z-axis.
|
| pyvista.DataObjectFilters.reflect
| Reflect a mesh.
|
| reflection, has_reflection
| Get info about the transform's reflection component.
|
| Examples
| --------
| Compose a reflection matrix.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform()
| >>> _ = transform.reflect(0, 0, 1)
| >>> transform.matrix
| array([[ 1., 0., 0., 0.],
| [ 0., 1., 0., 0.],
| [ 0., 0., -1., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second reflection matrix.
|
| >>> _ = transform.reflect((1, 0, 0))
| >>> transform.matrix
| array([[-1., 0., 0., 0.],
| [ 0., 1., 0., 0.],
| [ 0., 0., -1., 0.],
| [ 0., 0., 0., 1.]])
|
| rotate(self: 'Transform', rotation: 'RotationLike', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a rotation matrix.
|
| Create a rotation matrix and :meth:`compose` it with the current
| transformation :attr:`matrix` according to pre-multiply or post-multiply
| semantics. The rotation may be right-handed or left-handed.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the rotation
| - :meth:`translate` away from ``point`` after the rotation
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| rotate_x, rotate_y, rotate_z, rotate_vector
| Similar rotation methods.
| rotation_matrix, rotation_axis_angle, as_rotation, has_rotation
| Get this transform's rotation component.
| pyvista.DataObjectFilters.rotate
| Rotate a mesh.
|
| Examples
| --------
| Compose a rotation matrix. In this case the rotation rotates about the
| z-axis by 90 degrees.
|
| >>> import pyvista as pv
| >>> rotation_z_90 = [[0, -1, 0], [1, 0, 0], [0, 0, 1]]
| >>> transform = pv.Transform().rotate(rotation_z_90)
| >>> transform.matrix
| array([[ 0., -1., 0., 0.],
| [ 1., 0., 0., 0.],
| [ 0., 0., 1., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second rotation matrix. In this case we use the same rotation as
| before.
|
| >>> _ = transform.rotate(rotation_z_90)
|
| The result is a matrix that rotates about the z-axis by 180 degrees.
|
| >>> transform.matrix
| array([[-1., 0., 0., 0.],
| [ 0., -1., 0., 0.],
| [ 0., 0., 1., 0.],
| [ 0., 0., 0., 1.]])
|
| Rotate about a point. Check the :attr:`matrix_list` to see that a translation
| is added before and after the rotation.
|
| >>> transform = pv.Transform().rotate(rotation_z_90, point=(1, 2, 3))
| >>> translation_to_origin = transform.matrix_list[0]
| >>> translation_to_origin
| array([[ 1., 0., 0., -1.],
| [ 0., 1., 0., -2.],
| [ 0., 0., 1., -3.],
| [ 0., 0., 0., 1.]])
|
| >>> rotation = transform.matrix_list[1]
| >>> rotation
| array([[ 0., -1., 0., 0.],
| [ 1., 0., 0., 0.],
| [ 0., 0., 1., 0.],
| [ 0., 0., 0., 1.]])
|
| >>> translation_from_origin = transform.matrix_list[2]
| >>> translation_from_origin
| array([[1., 0., 0., 1.],
| [0., 1., 0., 2.],
| [0., 0., 1., 3.],
| [0., 0., 0., 1.]])
|
| rotate_vector(self: 'Transform', vector: 'VectorLike[float]', angle: 'float', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a rotation about a vector.
|
| Create a matrix for rotation about the vector and :meth:`compose`
| it with the current transformation :attr:`matrix` according to pre-multiply or
| post-multiply semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle in degrees to rotate about the vector.
|
| point : VectorLike[float], optional
| Point to rotate about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the rotation
| - :meth:`translate` away from ``point`` after the rotation
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| rotate_x, rotate_y, rotate_z, rotate
| Similar rotation methods.
| rotation_matrix, rotation_axis_angle, as_rotation, has_rotation
| Get this transform's rotation component.
| pyvista.DataObjectFilters.rotate_vector
| Rotate a mesh about a vector.
|
| Examples
| --------
| Compose a rotation of 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().rotate_vector((1, 1, 1), 30)
| >>> transform.matrix
| array([[ 0.9106836 , -0.24401694, 0.33333333, 0. ],
| [ 0.33333333, 0.9106836 , -0.24401694, 0. ],
| [-0.24401694, 0.33333333, 0.9106836 , 0. ],
| [ 0. , 0. , 0. , 1. ]])
|
| Compose a second rotation of 45 degrees about the ``(1, 2, 3)`` axis.
|
| >>> _ = transform.rotate_vector((1, 2, 3), 45)
| >>> transform.matrix
| array([[ 0.38042304, -0.50894634, 0.77217351, 0. ],
| [ 0.83349512, 0.55045308, -0.04782562, 0. ],
| [-0.40070461, 0.66179682, 0.63360933, 0. ],
| [ 0. , 0. , 0. , 1. ]])
|
| rotate_x(self: 'Transform', angle: 'float', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a rotation about the x-axis.
|
| Create a matrix for rotation about the x-axis and :meth:`compose`
| it with the current transformation :attr:`matrix` according to pre-multiply or
| post-multiply semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the rotation
| - :meth:`translate` away from ``point`` after the rotation
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| rotate_y, rotate_z, rotate_vector, rotate
| Similar rotation methods.
| rotation_matrix, rotation_axis_angle, as_rotation, has_rotation
| Get this transform's rotation component.
| pyvista.DataObjectFilters.rotate_x
| Rotate a mesh about the x-axis.
|
| Examples
| --------
| Compose a rotation about the x-axis.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().rotate_x(90)
| >>> transform.matrix
| array([[ 1., 0., 0., 0.],
| [ 0., 0., -1., 0.],
| [ 0., 1., 0., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second rotation about the x-axis.
|
| >>> _ = transform.rotate_x(45)
|
| The result is a matrix that rotates about the x-axis by 135 degrees.
|
| >>> transform.matrix
| array([[ 1. , 0. , 0. , 0. ],
| [ 0. , -0.70710678, -0.70710678, 0. ],
| [ 0. , 0.70710678, -0.70710678, 0. ],
| [ 0. , 0. , 0. , 1. ]])
|
| rotate_y(self: 'Transform', angle: 'float', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a rotation about the y-axis.
|
| Create a matrix for rotation about the y-axis and :meth:`compose`
| it with the current transformation :attr:`matrix` according to pre-multiply or
| post-multiply semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the rotation
| - :meth:`translate` away from ``point`` after the rotation
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| rotate_x, rotate_z, rotate_vector, rotate
| Similar rotation methods.
| rotation_matrix, rotation_axis_angle, as_rotation, has_rotation
| Get this transform's rotation component.
| pyvista.DataObjectFilters.rotate_y
| Rotate a mesh about the y-axis.
|
| Examples
| --------
| Compose a rotation about the y-axis.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().rotate_y(90)
| >>> transform.matrix
| array([[ 0., 0., 1., 0.],
| [ 0., 1., 0., 0.],
| [-1., 0., 0., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second rotation about the y-axis.
|
| >>> _ = transform.rotate_y(45)
|
| The result is a matrix that rotates about the y-axis by 135 degrees.
|
| >>> transform.matrix
| array([[-0.70710678, 0. , 0.70710678, 0. ],
| [ 0. , 1. , 0. , 0. ],
| [-0.70710678, 0. , -0.70710678, 0. ],
| [ 0. , 0. , 0. , 1. ]])
|
| rotate_z(self: 'Transform', angle: 'float', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a rotation about the z-axis.
|
| Create a matrix for rotation about the z-axis and :meth:`compose`
| it with the current transformation :attr:`matrix` according to pre-multiply or
| post-multiply semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the rotation
| - :meth:`translate` away from ``point`` after the rotation
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| rotate_x, rotate_y, rotate_vector, rotate
| Similar rotation methods.
| rotation_matrix, rotation_axis_angle, as_rotation, has_rotation
| Get this transform's rotation component.
| pyvista.DataObjectFilters.rotate_z
| Rotate a mesh about the z-axis.
|
| Examples
| --------
| Compose a rotation about the z-axis.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().rotate_z(90)
| >>> transform.matrix
| array([[ 0., -1., 0., 0.],
| [ 1., 0., 0., 0.],
| [ 0., 0., 1., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second rotation about the z-axis.
|
| >>> _ = transform.rotate_z(45)
|
| The result is a matrix that rotates about the z-axis by 135 degrees.
|
| >>> transform.matrix
| array([[-0.70710678, -0.70710678, 0. , 0. ],
| [ 0.70710678, -0.70710678, 0. , 0. ],
| [ 0. , 0. , 1. , 0. ],
| [ 0. , 0. , 0. , 1. ]])
|
| scale(self: 'Transform', *factor: 'float | VectorLike[float]', point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a scale matrix.
|
| Create a scale matrix and :meth:`compose` it with the current
| transformation :attr:`matrix` according to pre-multiply or post-multiply
| semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| *factor : float | VectorLike[float]
| Scale factor(s) to use. Use a single number for uniform scaling or
| three numbers for non-uniform scaling. The three factors may be
| passed as a single vector (one arg) or an unpacked vector (three args).
|
| point : VectorLike[float], optional
| Point to scale from. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the scaling
| - :meth:`translate` away from ``point`` after the scaling
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| pyvista.DataObjectFilters.scale
| Scale a mesh.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| scale_factors, has_scale
| Get info about the transform's scale component.
|
| Examples
| --------
| Compose a scale matrix.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().scale(1, 2, 3)
| >>> transform.matrix
| array([[1., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 3., 0.],
| [0., 0., 0., 1.]])
|
| Compose a second scale matrix using ``*``.
|
| >>> transform = transform * 2
| >>> transform.matrix
| array([[2., 0., 0., 0.],
| [0., 4., 0., 0.],
| [0., 0., 6., 0.],
| [0., 0., 0., 1.]])
|
| Scale from a point. Check the :attr:`matrix_list` to see that a translation
| is added before and after the scaling.
|
| >>> transform = pv.Transform().scale(7, point=(1, 2, 3))
| >>> translation_to_origin = transform.matrix_list[0]
| >>> translation_to_origin
| array([[ 1., 0., 0., -1.],
| [ 0., 1., 0., -2.],
| [ 0., 0., 1., -3.],
| [ 0., 0., 0., 1.]])
|
| >>> scale = transform.matrix_list[1]
| >>> scale
| array([[7., 0., 0., 0.],
| [0., 7., 0., 0.],
| [0., 0., 7., 0.],
| [0., 0., 0., 1.]])
|
| >>> translation_from_origin = transform.matrix_list[2]
| >>> translation_from_origin
| array([[1., 0., 0., 1.],
| [0., 1., 0., 2.],
| [0., 0., 1., 3.],
| [0., 0., 0., 1.]])
|
| translate(self: 'Transform', *vector: 'float | VectorLike[float]', multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a translation matrix.
|
| Create a translation matrix and :meth:`compose` it with the current
| transformation :attr:`matrix` according to pre-multiply or post-multiply
| semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| *vector : float | VectorLike[float]
| Vector to use for translation. May be a single vector (one arg) or
| unpacked vector (three args).
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| pyvista.DataObjectFilters.translate
| Translate a mesh.
|
| translation, has_translation
| Get info about the transform's translation component.
|
| Examples
| --------
| Compose a translation matrix.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().translate(1, 2, 3)
| >>> transform.matrix
| array([[1., 0., 0., 1.],
| [0., 1., 0., 2.],
| [0., 0., 1., 3.],
| [0., 0., 0., 1.]])
|
| Compose a second translation matrix using ``+``.
|
| >>> transform = transform + (1, 1, 1)
| >>> transform.matrix
| array([[1., 0., 0., 2.],
| [0., 1., 0., 3.],
| [0., 0., 1., 4.],
| [0., 0., 0., 1.]])
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| has_reflection
| Return ``True`` if the current transformation :attr:`~Transform.matrix` has a reflection component.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| reflection, reflect, decompose
|
| has_rotation
| Return ``True`` if the current transformation :attr:`~Transform.matrix` has a rotation component.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| rotation_matrix, rotate, decompose
|
| has_scale
| Return ``True`` if the current transformation :attr:`~Transform.matrix` has a scale component.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| scale_factors, scale, decompose
|
| has_shear
| Return ``True`` if the current transformation :attr:`~Transform.matrix` has a shear component.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| shear_matrix, compose, decompose
|
| has_translation
| Return ``True`` if the current transformation :attr:`~Transform.matrix` has a translation component.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| translation, translate, decompose
|
| inverse_matrix
| Return the inverse of the current transformation :attr:`~Transform.matrix`.
|
| Notes
| -----
| This matrix is a single 4x4 matrix computed from composing the inverse of
| all transformations. Use :attr:`inverse_matrix_list` instead to get a list of
| the individual inverse transformations.
|
| See Also
| --------
| matrix
| Return the current transformation matrix.
|
| Returns
| -------
| NDArray[float]
| Current inverse transformation matrix.
|
| inverse_matrix_list
| Return a list of all inverse transformations applied by this :class:`Transform`.
|
| Notes
| -----
| The list comprises all 4x4 inverse transformation matrices. Use
| :attr:`inverse_matrix` instead to get the composed result as a single
| 4x4 matrix.
|
| See Also
| --------
| matrix_list
| Return a list of all transformation matrices.
|
| Returns
| -------
| list[NDArray[float]]
| List of all current inverse transformation matrices.
|
| is_inverted
| Get the inverse flag of the transformation.
|
| This flag is modified whenever :meth:`invert` is called.
|
| matrix_list
| Return a list of all current transformation matrices.
|
| Notes
| -----
| The list comprises all 4x4 transformation matrices. Use :attr:`matrix` instead
| to get the composed result as a single 4x4 matrix.
|
| See Also
| --------
| inverse_matrix_list
| Return the current transformation matrix.
|
| Returns
| -------
| list[NDArray[float]]
| List of all current transformation matrices.
|
| n_transformations
| Return the current number of composed transformations.
|
| reflection
| Return the reflection component of the current transformation :attr:`~Transform.matrix` as an integer.
|
| ``1`` is returned if there is no reflection, and ``-1`` is returned if there
| is a reflection.
|
| See Also
| --------
| has_reflection, reflect, decompose
|
| Examples
| --------
| Create a transform and get its reflection.
|
| >>> import pyvista as pv
| >>> trans = pv.Transform()
| >>> trans.reflection
| 1
|
| Compose a reflection about the x-axis and get the reflection again.
|
| >>> _ = trans.flip_x()
| >>> trans.reflection
| -1
|
| Compose a second reflection and get the reflection again.
|
| >>> _ = trans.flip_y()
| >>> trans.reflection
| 1
|
| rotation_axis_angle
| Return the rotation component of the current transformation :attr:`~Transform.matrix` as a vector and angle.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| has_rotation, rotation_matrix, rotate_vector, as_rotation, decompose
|
| Examples
| --------
| Compose a rotation from a vector and angle.
|
| >>> import pyvista as pv
| >>> trans = pv.Transform().rotate_vector((1, 2, 3), 30)
|
| Get the rotation axis and angle.
|
| >>> axis, angle = trans.rotation_axis_angle
| >>> axis
| (0.2672, 0.5345, 0.8017)
| >>> angle
| 30.0
|
| Compose a second rotation around the same axis and get the axis and angle again.
|
| >>> _ = trans.rotate_vector((1, 2, 3), 40)
| >>> axis, angle = trans.rotation_axis_angle
| >>> axis
| (0.2672, 0.5345, 0.8017)
| >>> angle
| 70.0
|
| rotation_matrix
| Return the rotation component of the current transformation :attr:`~Transform.matrix` as a 3x3 matrix.
|
| The rotation is orthonormal and right-handed with positive determinant.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| has_rotation, rotation_axis_angle, rotate, as_rotation, decompose
|
| Examples
| --------
| Compose a rotation about the z-axis.
|
| >>> import pyvista as pv
| >>> trans = pv.Transform().rotate_z(90)
|
| Get the rotation matrix.
|
| >>> trans.rotation_matrix
| array([[ 0., -1., 0.],
| [ 1., 0., 0.],
| [ 0., 0., 1.]])
|
| Compose a second rotation and get the rotation matrix again.
|
| >>> _ = trans.rotate_y(-90)
| >>> trans.rotation_matrix
| array([[ 0., 0., -1.],
| [ 1., 0., 0.],
| [ 0., -1., 0.]])
|
| scale_factors
| Return the scaling component of the current transformation :attr:`~Transform.matrix`.
|
| The scaling factors are always positive.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| has_scale, scale, decompose
|
| Examples
| --------
| Compose a scale matrix and get the scale factors.
|
| >>> import pyvista as pv
| >>> trans = pv.Transform() * (1, 2, 3)
| >>> trans.scale_factors
| (1.0, 2.0, 3.0)
|
| Compose a second scale matrix and get the factors again.
|
| >>> trans *= (4, 5, 6)
| >>> trans.scale_factors
| (4.0, 10.0, 18.0)
|
| shear_matrix
| Return the shear component of the current transformation :attr:`~Transform.matrix` as a 3x3 matrix.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| has_shear, compose, decompose
|
| Examples
| --------
| Compose a symmetric shear matrix.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> shear = np.eye(4)
| >>> shear[0, 1] = 0.1
| >>> shear[1, 0] = 0.1
| >>> trans = pv.Transform(shear)
|
| Get the shear matrix. The shear matrix is the same as the input in this particular example,
| but in general this is not the case.
|
| >>> trans.shear_matrix
| array([[1. , 0.1, 0. ],
| [0.1, 1. , 0. ],
| [0. , 0. , 1. ]])
|
| Compose an asymmetric shear matrix instead.
|
| >>> shear = np.eye(4)
| >>> shear[0, 1] = 0.1
| >>> trans = pv.Transform(shear)
|
| Get the shear matrix. In this case, shear differs from the input because asymmetric shear
| can be decomposed into scale factors and a rotation.
|
| >>> trans.shear_matrix
| array([[1. , 0.05 , 0. ],
| [0.04975124, 1. , 0. ],
| [0. , 0. , 1. ]])
|
| >>> trans.scale_factors
| (0.9987523388778445, 1.0037461005722337, 1.0)
|
| >>> axis, angle = trans.rotation_axis_angle
| >>> axis
| (0.0, 0.0, -1.0)
| >>> angle
| 2.8624
|
| translation
| Return the translation component of the current transformation :attr:`~Transform.matrix`.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| has_translation, translate, decompose
|
| Examples
| --------
| Compose a translation and get the translation component.
|
| >>> import pyvista as pv
| >>> trans = pv.Transform() + (1, 2, 3)
| >>> trans.translation
| (1.0, 2.0, 3.0)
|
| Compose a second translation and get the component again.
|
| >>> trans += (4, 5, 6)
| >>> trans.translation
| (5.0, 7.0, 9.0)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| check_finite
| Check that the :attr:`~Transform.matrix` and :attr:`~Transform.inverse_matrix` have finite values.
|
| If ``True``, all transformations are checked to ensure they only contain
| finite values (i.e. no ``NaN`` or ``Inf`` values) and a ``ValueError`` is raised
| otherwise. This is useful to catch cases where the transformation(s) are poorly
| defined and/or are numerically unstable.
|
| This flag is enabled by default.
|
| matrix
| Return or set the current transformation matrix.
|
| Notes
| -----
| This matrix is a single 4x4 matrix computed from composing all
| transformations. Use :attr:`matrix_list` instead to get a list of the
| individual transformations.
|
| See Also
| --------
| inverse_matrix
| Return the inverse of the current transformation.
|
| Returns
| -------
| NDArray[float]
| Current transformation matrix.
|
| multiply_mode
| Set or get the multiplication mode.
|
| Set this to ``'pre'`` to set the multiplication mode to :meth:`pre_multiply`.
| Set this to ``'post'`` to set it to :meth:`post_multiply`.
|
| In pre-multiply mode, any additional transformations (e.g. using
| :meth:`translate`, :meth:`compose`, etc.) will occur *before* any
| transformations represented by the current :attr:`matrix`.
| In post-multiply mode, the additional transformation will occur *after* any
| transformations represented by the current matrix.
|
| point
| Point to use when composing some transformations such as scale, rotation, etc.
|
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the transformation
| - :meth:`translate` away from ``point`` after the transformation
|
| By default, this value is ``None``, which means that the scale, rotation, etc.
| transformations are performed about the origin ``(0, 0, 0)``.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonTransforms.vtkTransform:
|
| CircuitCheck(...)
| CircuitCheck(self, transform:vtkAbstractTransform) -> int
| C++: int CircuitCheck(vtkAbstractTransform *transform) override;
|
| Check for self-reference. Will return true if concatenating with
| the specified transform, setting it to be our inverse, or setting
| it to be our input will create a circular reference. CircuitCheck
| is automatically called by SetInput(), SetInverse(), and
| Concatenate(vtkXTransform *). Avoid using this function, it is
| experimental.
|
| Concatenate(...)
| Concatenate(self, matrix:vtkMatrix4x4) -> None
| C++: void Concatenate(vtkMatrix4x4 *matrix)
| Concatenate(self, elements:(float, float, float, float, float,
| float, float, float, float, float, float, float, float, float,
| float, float)) -> None
| C++: void Concatenate(const double elements[16])
| Concatenate(self, transform:vtkLinearTransform) -> None
| C++: void Concatenate(vtkLinearTransform *transform)
|
| Concatenates the matrix with the current transformation according
| to PreMultiply or PostMultiply semantics.
|
| GetConcatenatedTransform(...)
| GetConcatenatedTransform(self, i:int) -> vtkLinearTransform
| C++: vtkLinearTransform *GetConcatenatedTransform(int i)
|
| Get one of the concatenated transformations as a
| vtkAbstractTransform. These transformations are applied, in
| series, every time the transformation of a coordinate occurs.
| This method is provided to make it possible to decompose a
| transformation into its constituents, for example to save a
| transformation to a file.
|
| GetInput(...)
| GetInput(self) -> vtkLinearTransform
| C++: vtkLinearTransform *GetInput()
|
| GetInverse(...)
| GetInverse(self, inverse:vtkMatrix4x4) -> None
| C++: void GetInverse(vtkMatrix4x4 *inverse)
| GetInverse(self) -> vtkAbstractTransform
| C++: vtkAbstractTransform *GetInverse()
|
| Return a matrix which is the inverse of the current
| transformation matrix.
|
| GetInverseFlag(...)
| GetInverseFlag(self) -> int
| C++: vtkTypeBool GetInverseFlag()
|
| Get the inverse flag of the transformation. This controls
| whether it is the Input or the inverse of the Input that is used
| as the base transformation. The InverseFlag is flipped every
| time Inverse() is called. The InverseFlag is off when a
| transform is first created.
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Override GetMTime to account for input and concatenation.
|
| GetNumberOfConcatenatedTransforms(...)
| GetNumberOfConcatenatedTransforms(self) -> int
| C++: int GetNumberOfConcatenatedTransforms()
|
| Get the total number of transformations that are linked into this
| one via Concatenate() operations or via SetInput().
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOrientation(...)
| GetOrientation(self, orient:[float, float, float]) -> None
| C++: void GetOrientation(double orient[3])
| GetOrientation(self) -> (float, float, float)
| C++: double *GetOrientation()
| GetOrientation(orient:[float, float, float], matrix:vtkMatrix4x4)
| -> None
| C++: static void GetOrientation(double orient[3],
| vtkMatrix4x4 *matrix)
|
| Get the x, y, z orientation angles from the transformation matrix
| as an array of three floating point values.
|
| GetOrientationWXYZ(...)
| GetOrientationWXYZ(self, wxyz:[float, float, float, float])
| -> None
| C++: void GetOrientationWXYZ(double wxyz[4])
| GetOrientationWXYZ(self) -> (float, float, float, float)
| C++: double *GetOrientationWXYZ()
|
| Return the wxyz angle+axis representing the current orientation.
| The angle is in degrees and the axis is a unit vector.
|
| GetPosition(...)
| GetPosition(self, pos:[float, float, float]) -> None
| C++: void GetPosition(double pos[3])
| GetPosition(self) -> (float, float, float)
| C++: double *GetPosition()
|
| Return the position from the current transformation matrix as an
| array of three floating point numbers. This is simply returning
| the translation component of the 4x4 matrix.
|
| GetScale(...)
| GetScale(self, scale:[float, float, float]) -> None
| C++: void GetScale(double scale[3])
| GetScale(self) -> (float, float, float)
| C++: double *GetScale()
|
| Return the scale factors of the current transformation matrix as
| an array of three float numbers. These scale factors are not
| necessarily about the x, y, and z axes unless unless the scale
| transformation was applied before any rotations.
|
| GetTranspose(...)
| GetTranspose(self, transpose:vtkMatrix4x4) -> None
| C++: void GetTranspose(vtkMatrix4x4 *transpose)
|
| Return a matrix which is the transpose of the current
| transformation matrix. This is equivalent to the inverse if and
| only if the transformation is a pure rotation with no translation
| or scale.
|
| Identity(...)
| Identity(self) -> None
| C++: void Identity()
|
| Set the transformation to the identity transformation. If the
| transform has an Input, then the transformation will be reset so
| that it is the same as the Input.
|
| Inverse(...)
| Inverse(self) -> None
| C++: void Inverse() override;
|
| Invert the transformation. This will also set a flag so that the
| transformation will use the inverse of its Input, if an Input has
| been set.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| MakeTransform(...)
| MakeTransform(self) -> vtkAbstractTransform
| C++: vtkAbstractTransform *MakeTransform() override;
|
| Make a new transform of the same type.
|
| MultiplyPoint(...)
| MultiplyPoint(self, in_:(float, float, float, float), out:[float,
| float, float, float]) -> None
| C++: void MultiplyPoint(const double in[4], double out[4])
|
| NewInstance(...)
| NewInstance(self) -> vtkTransform
| C++: vtkTransform *NewInstance()
|
| Pop(...)
| Pop(self) -> None
| C++: void Pop()
|
| Deletes the transformation on the top of the stack and sets the
| top to the next transformation on the stack.
|
| PostMultiply(...)
| PostMultiply(self) -> None
| C++: void PostMultiply()
|
| Sets the internal state of the transform to PostMultiply. All
| subsequent operations will occur after those already represented
| in the current transformation. In homogeneous matrix notation, M
| = A*M where M is the current transformation matrix and A is the
| applied matrix. The default is PreMultiply.
|
| PreMultiply(...)
| PreMultiply(self) -> None
| C++: void PreMultiply()
|
| Sets the internal state of the transform to PreMultiply. All
| subsequent operations will occur before those already represented
| in the current transformation. In homogeneous matrix notation, M
| = M*A where M is the current transformation matrix and A is the
| applied matrix. The default is PreMultiply.
|
| Push(...)
| Push(self) -> None
| C++: void Push()
|
| Pushes the current transformation onto the transformation stack.
|
| RotateWXYZ(...)
| RotateWXYZ(self, angle:float, x:float, y:float, z:float) -> None
| C++: void RotateWXYZ(double angle, double x, double y, double z)
| RotateWXYZ(self, angle:float, axis:(float, float, float)) -> None
| C++: void RotateWXYZ(double angle, const double axis[3])
|
| Create a rotation matrix and concatenate it with the current
| transformation according to PreMultiply or PostMultiply
| semantics. The angle is in degrees, and (x,y,z) specifies the
| axis that the rotation will be performed around.
|
| RotateX(...)
| RotateX(self, angle:float) -> None
| C++: void RotateX(double angle)
|
| Create a rotation matrix about the X, Y, or Z axis and
| concatenate it with the current transformation according to
| PreMultiply or PostMultiply semantics. The angle is expressed in
| degrees.
|
| RotateY(...)
| RotateY(self, angle:float) -> None
| C++: void RotateY(double angle)
|
| RotateZ(...)
| RotateZ(self, angle:float) -> None
| C++: void RotateZ(double angle)
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkTransform
| C++: static vtkTransform *SafeDownCast(vtkObjectBase *o)
|
| Scale(...)
| Scale(self, x:float, y:float, z:float) -> None
| C++: void Scale(double x, double y, double z)
| Scale(self, s:(float, float, float)) -> None
| C++: void Scale(const double s[3])
|
| Create a scale matrix (i.e. set the diagonal elements to x, y, z)
| and concatenate it with the current transformation according to
| PreMultiply or PostMultiply semantics.
|
| SetInput(...)
| SetInput(self, input:vtkLinearTransform) -> None
| C++: void SetInput(vtkLinearTransform *input)
|
| Set the input for this transformation. This will be used as the
| base transformation if it is set. This method allows you to
| build a transform pipeline: if the input is modified, then this
| transformation will automatically update accordingly. Note that
| the InverseFlag, controlled via Inverse(), determines whether
| this transformation will use the Input or the inverse of the
| Input.
|
| SetMatrix(...)
| SetMatrix(self, matrix:vtkMatrix4x4) -> None
| C++: void SetMatrix(vtkMatrix4x4 *matrix)
| SetMatrix(self, elements:(float, float, float, float, float,
| float, float, float, float, float, float, float, float, float,
| float, float)) -> None
| C++: void SetMatrix(const double elements[16])
|
| Set the current matrix directly. Note: First, the current matrix
| is set to the identity, then the input matrix is concatenated.
|
| Translate(...)
| Translate(self, x:float, y:float, z:float) -> None
| C++: void Translate(double x, double y, double z)
| Translate(self, x:(float, float, float)) -> None
| C++: void Translate(const double x[3])
|
| Create a translation matrix and concatenate it with the current
| transformation according to PreMultiply or PostMultiply
| semantics.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkCommonTransforms.vtkTransform:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkCommonTransforms.vtkTransform
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonTransforms.vtkTransform:
|
| __this__
| Pointer to the C++ object.
|
| input
| read-write, calls GetInput/SetInput
|
| inverse
| read-only, calls GetInverse
|
| inverse_flag
| read-only, calls GetInverseFlag
|
| m_time
| read-only, calls GetMTime
|
| number_of_concatenated_transforms
| read-only, calls GetNumberOfConcatenatedTransforms
|
| orientation
| read-only, calls GetOrientation
|
| orientation_wxyz
| read-only, calls GetOrientationWXYZ
|
| position
| read-only, calls GetPosition
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonTransforms.vtkTransform:
|
| __vtkname__ = 'vtkTransform'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonTransforms.vtkLinearTransform:
|
| GetLinearInverse(...)
| GetLinearInverse(self) -> vtkLinearTransform
| C++: vtkLinearTransform *GetLinearInverse()
|
| Just like GetInverse, but it includes a typecast to
| vtkLinearTransform.
|
| InternalTransformDerivative(...)
| InternalTransformDerivative(self, in_:(float, float, float),
| out:[float, float, float], derivative:[[float, float, float],
| [float, float, float], [float, float, float]]) -> None
| C++: void InternalTransformDerivative(const double in[3],
| double out[3], double derivative[3][3]) override;
|
| InternalTransformNormal(...)
| InternalTransformNormal(self, in_:(float, float, float),
| out:[float, float, float]) -> None
| C++: virtual void InternalTransformNormal(const double in[3],
| double out[3])
|
| InternalTransformPoint(...)
| InternalTransformPoint(self, in_:(float, float, float),
| out:[float, float, float]) -> None
| C++: void InternalTransformPoint(const double in[3],
| double out[3]) override;
|
| InternalTransformVector(...)
| InternalTransformVector(self, in_:(float, float, float),
| out:[float, float, float]) -> None
| C++: virtual void InternalTransformVector(const double in[3],
| double out[3])
|
| TransformDoubleNormal(...)
| TransformDoubleNormal(self, x:float, y:float, z:float) -> (float,
| float, float)
| C++: double *TransformDoubleNormal(double x, double y, double z)
| TransformDoubleNormal(self, normal:(float, float, float)) -> (
| float, float, float)
| C++: double *TransformDoubleNormal(const double normal[3])
|
| Apply the transformation to a double-precision (x,y,z) normal.
| Use this if you are programming in python or Java.
|
| TransformDoubleVector(...)
| TransformDoubleVector(self, x:float, y:float, z:float) -> (float,
| float, float)
| C++: double *TransformDoubleVector(double x, double y, double z)
| TransformDoubleVector(self, vec:(float, float, float)) -> (float,
| float, float)
| C++: double *TransformDoubleVector(const double vec[3])
|
| Apply the transformation to a double-precision (x,y,z) vector.
| Use this if you are programming in python or Java.
|
| TransformFloatNormal(...)
| TransformFloatNormal(self, x:float, y:float, z:float) -> (float,
| float, float)
| C++: float *TransformFloatNormal(float x, float y, float z)
| TransformFloatNormal(self, normal:(float, float, float)) -> (
| float, float, float)
| C++: float *TransformFloatNormal(const float normal[3])
|
| Apply the transformation to an (x,y,z) normal. Use this if you
| are programming in python or Java.
|
| TransformFloatVector(...)
| TransformFloatVector(self, x:float, y:float, z:float) -> (float,
| float, float)
| C++: float *TransformFloatVector(float x, float y, float z)
| TransformFloatVector(self, vec:(float, float, float)) -> (float,
| float, float)
| C++: float *TransformFloatVector(const float vec[3])
|
| Apply the transformation to an (x,y,z) vector. Use this if you
| are programming in python or Java.
|
| TransformNormal(...)
| TransformNormal(self, in_:(float, float, float), out:[float,
| float, float]) -> None
| C++: void TransformNormal(const double in[3], double out[3])
| TransformNormal(self, x:float, y:float, z:float) -> (float, float,
| float)
| C++: double *TransformNormal(double x, double y, double z)
| TransformNormal(self, normal:(float, float, float)) -> (float,
| float, float)
| C++: double *TransformNormal(const double normal[3])
|
| Apply the transformation to a double-precision normal. You can
| use the same array to store both the input and output.
|
| TransformNormals(...)
| TransformNormals(self, inNms:vtkDataArray, outNms:vtkDataArray)
| -> None
| C++: virtual void TransformNormals(vtkDataArray *inNms,
| vtkDataArray *outNms)
|
| Apply the transformation to a series of normals, and append the
| results to outNms.
|
| TransformPoints(...)
| TransformPoints(self, inPts:vtkPoints, outPts:vtkPoints) -> None
| C++: void TransformPoints(vtkPoints *inPts, vtkPoints *outPts)
| override;
|
| Apply the transformation to a series of points, and append the
| results to outPts.
|
| TransformVector(...)
| TransformVector(self, x:float, y:float, z:float) -> (float, float,
| float)
| C++: double *TransformVector(double x, double y, double z)
| TransformVector(self, normal:(float, float, float)) -> (float,
| float, float)
| C++: double *TransformVector(const double normal[3])
| TransformVector(self, in_:(float, float, float), out:[float,
| float, float]) -> None
| C++: void TransformVector(const double in[3], double out[3])
|
| Synonymous with TransformDoubleVector(x,y,z). Use this if you are
| programming in python or Java.
|
| TransformVectors(...)
| TransformVectors(self, inVrs:vtkDataArray, outVrs:vtkDataArray)
| -> None
| C++: virtual void TransformVectors(vtkDataArray *inVrs,
| vtkDataArray *outVrs)
|
| Apply the transformation to a series of vectors, and append the
| results to outVrs.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonTransforms.vtkLinearTransform:
|
| linear_inverse
| read-only, calls GetLinearInverse
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonTransforms.vtkHomogeneousTransform:
|
| GetHomogeneousInverse(...)
| GetHomogeneousInverse(self) -> vtkHomogeneousTransform
| C++: vtkHomogeneousTransform *GetHomogeneousInverse()
|
| Just like GetInverse(), but includes typecast to
| vtkHomogeneousTransform.
|
| GetMatrix(...)
| GetMatrix(self, m:vtkMatrix4x4) -> None
| C++: void GetMatrix(vtkMatrix4x4 *m)
| GetMatrix(self) -> vtkMatrix4x4
| C++: vtkMatrix4x4 *GetMatrix()
|
| Get a copy of the internal transformation matrix. The transform
| is Updated first, to guarantee that the matrix is valid.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonTransforms.vtkHomogeneousTransform:
|
| homogeneous_inverse
| read-only, calls GetHomogeneousInverse
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonTransforms.vtkAbstractTransform:
|
| DeepCopy(...)
| DeepCopy(self, __a:vtkAbstractTransform) -> None
| C++: void DeepCopy(vtkAbstractTransform *)
|
| Copy this transform from another of the same type.
|
| Modified(...)
| Modified(self) -> None
| C++: void Modified() override;
|
| Override Modified to avoid ModifiedEvent during update.
|
| SetInverse(...)
| SetInverse(self, transform:vtkAbstractTransform) -> None
| C++: void SetInverse(vtkAbstractTransform *transform)
|
| Set a transformation that this transform will be the inverse of.
| This transform will automatically update to agree with the
| inverse transform that you set.
|
| TransformDoubleNormalAtPoint(...)
| TransformDoubleNormalAtPoint(self, point:(float, float, float),
| normal:(float, float, float)) -> (float, float, float)
| C++: double *TransformDoubleNormalAtPoint(const double point[3],
| const double normal[3])
|
| Apply the transformation to a double-precision normal at the
| specified vertex. If the transformation is a vtkLinearTransform,
| you can use TransformDoubleNormal() instead.
|
| TransformDoublePoint(...)
| TransformDoublePoint(self, x:float, y:float, z:float) -> (float,
| float, float)
| C++: double *TransformDoublePoint(double x, double y, double z)
| TransformDoublePoint(self, point:(float, float, float)) -> (float,
| float, float)
| C++: double *TransformDoublePoint(const double point[3])
|
| Apply the transformation to a double-precision (x,y,z)
| coordinate. Use this if you are programming in Python or Java.
|
| TransformDoubleVectorAtPoint(...)
| TransformDoubleVectorAtPoint(self, point:(float, float, float),
| vector:(float, float, float)) -> (float, float, float)
| C++: double *TransformDoubleVectorAtPoint(const double point[3],
| const double vector[3])
|
| Apply the transformation to a double-precision vector at the
| specified vertex. If the transformation is a vtkLinearTransform,
| you can use TransformDoubleVector() instead.
|
| TransformFloatNormalAtPoint(...)
| TransformFloatNormalAtPoint(self, point:(float, float, float),
| normal:(float, float, float)) -> (float, float, float)
| C++: float *TransformFloatNormalAtPoint(const float point[3],
| const float normal[3])
|
| Apply the transformation to a single-precision normal at the
| specified vertex. If the transformation is a vtkLinearTransform,
| you can use TransformFloatNormal() instead.
|
| TransformFloatPoint(...)
| TransformFloatPoint(self, x:float, y:float, z:float) -> (float,
| float, float)
| C++: float *TransformFloatPoint(float x, float y, float z)
| TransformFloatPoint(self, point:(float, float, float)) -> (float,
| float, float)
| C++: float *TransformFloatPoint(const float point[3])
|
| Apply the transformation to an (x,y,z) coordinate. Use this if
| you are programming in Python or Java.
|
| TransformFloatVectorAtPoint(...)
| TransformFloatVectorAtPoint(self, point:(float, float, float),
| vector:(float, float, float)) -> (float, float, float)
| C++: float *TransformFloatVectorAtPoint(const float point[3],
| const float vector[3])
|
| Apply the transformation to a single-precision vector at the
| specified vertex. If the transformation is a vtkLinearTransform,
| you can use TransformFloatVector() instead.
|
| TransformNormalAtPoint(...)
| TransformNormalAtPoint(self, point:(float, float, float), in_:(
| float, float, float), out:[float, float, float]) -> None
| C++: void TransformNormalAtPoint(const double point[3],
| const double in[3], double out[3])
| TransformNormalAtPoint(self, point:(float, float, float), normal:(
| float, float, float)) -> (float, float, float)
| C++: double *TransformNormalAtPoint(const double point[3],
| const double normal[3])
|
| TransformPoint(...)
| TransformPoint(self, in_:(float, float, float), out:[float, float,
| float]) -> None
| C++: void TransformPoint(const double in[3], double out[3])
| TransformPoint(self, x:float, y:float, z:float) -> (float, float,
| float)
| C++: double *TransformPoint(double x, double y, double z)
| TransformPoint(self, point:(float, float, float)) -> (float,
| float, float)
| C++: double *TransformPoint(const double point[3])
|
| Apply the transformation to a double-precision coordinate. You
| can use the same array to store both the input and output point.
|
| TransformVectorAtPoint(...)
| TransformVectorAtPoint(self, point:(float, float, float), in_:(
| float, float, float), out:[float, float, float]) -> None
| C++: void TransformVectorAtPoint(const double point[3],
| const double in[3], double out[3])
| TransformVectorAtPoint(self, point:(float, float, float), vector:(
| float, float, float)) -> (float, float, float)
| C++: double *TransformVectorAtPoint(const double point[3],
| const double vector[3])
|
| Update(...)
| Update(self) -> None
| C++: void Update()
|
| Update the transform to account for any changes which have been
| made. You do not have to call this method yourself, it is called
| automatically whenever the transform needs an update.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.TransformLike
Python Library Documentation: _UnionGenericAlias in module typing
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
pyvista.Triangle
Python Library Documentation: function Triangle in module pyvista.core.utilities.geometric_objects
Triangle(points: 'MatrixLike[float] | None' = None) -> 'PolyData'
Create a triangle defined by 3 points.
Parameters
----------
points : array_like[float], optional
Points of the triangle. Defaults to a right isosceles
triangle (see example).
Returns
-------
pyvista.PolyData
Triangle mesh.
Examples
--------
>>> import pyvista as pv
>>> pointa = [0, 0, 0]
>>> pointb = [1, 0, 0]
>>> pointc = [0.5, 0.707, 0]
>>> triangle = pv.Triangle([pointa, pointb, pointc])
>>> triangle.plot(show_edges=True, line_width=5)
pyvista.Tube
Python Library Documentation: function Tube in module pyvista.core.utilities.geometric_objects
Tube(pointa: 'VectorLike[float]' = (-0.5, 0.0, 0.0), pointb: 'VectorLike[float]' = (0.5, 0.0, 0.0), resolution: 'int' = 1, radius: 'float' = 1.0, n_sides: 'int' = 15, capping: 'bool' = False) -> 'PolyData'
Create a tube.
Parameters
----------
pointa : sequence[float], default: (-0.5, 0.0, 0.0)
Location in ``[x, y, z]``.
pointb : sequence[float], default: (0.5, 0.0, 0.0)
Location in ``[x, y, z]``.
resolution : int, default: 1
Number of pieces to divide tube into.
radius : float, default: 1.0
Minimum tube radius (minimum because the tube radius may vary).
n_sides : int, default: 15
Number of sides for the tube.
capping : bool, default: False
Turn on/off whether to cap the ends with polygons.
.. versionadded:: 0.45
Returns
-------
pyvista.PolyData
Tube mesh.
Examples
--------
Create a tube between ``(0, 0, 0)`` and ``(0, 0, 1)``.
>>> import pyvista as pv
>>> mesh = pv.Tube(pointa=(0, 0, 0), pointb=(0, 0, 1))
>>> mesh.plot()
pyvista.UnstructuredGrid
Python Library Documentation: class UnstructuredGrid in module pyvista.core.pointset
class UnstructuredGrid(PointGrid, pyvista.core.filters.unstructured_grid.UnstructuredGridFilters, vtkmodules.vtkCommonDataModel.vtkUnstructuredGrid)
| UnstructuredGrid(*args, **kwargs) -> '_T'
|
| Dataset used for arbitrary combinations of all possible cell types.
|
| Can be initialized by the following:
|
| - Creating an empty grid
| - From a :vtk:`vtkPolyData` or :vtk:`vtkStructuredGrid` object
| - From cell, cell types, and point arrays
| - From a file
|
| Parameters
| ----------
| args : str, :vtk:`vtkUnstructuredGrid`, iterable
| See examples below.
|
| deep : bool, default: False
| Whether to deep copy a :vtk:`vtkUnstructuredGrid` object.
| Default is ``False``. Keyword only.
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import vtk
|
| Create an empty grid
|
| >>> grid = pv.UnstructuredGrid()
|
| Copy a :vtk:`vtkUnstructuredGrid`
|
| >>> vtkgrid = vtk.vtkUnstructuredGrid()
| >>> grid = pv.UnstructuredGrid(vtkgrid)
|
| From a filename.
|
| >>> grid = pv.UnstructuredGrid(examples.hexbeamfile)
| >>> grid.plot(show_edges=True)
|
| From arrays. Here we create a single tetrahedron.
|
| >>> cells = [4, 0, 1, 2, 3]
| >>> celltypes = [pv.CellType.TETRA]
| >>> points = [
| ... [1.0, 1.0, 1.0],
| ... [1.0, -1.0, -1.0],
| ... [-1.0, 1.0, -1.0],
| ... [-1.0, -1.0, 1.0],
| ... ]
| >>> grid = pv.UnstructuredGrid(cells, celltypes, points)
| >>> grid.plot(show_edges=True)
|
| See the :ref:`create_unstructured_surface_example` example for more details
| on creating unstructured grids within PyVista.
|
| Method resolution order:
| UnstructuredGrid
| PointGrid
| _PointSet
| pyvista.core.dataset.DataSet
| pyvista.core.filters.unstructured_grid.UnstructuredGridFilters
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkUnstructuredGrid
| vtkmodules.vtkCommonDataModel.vtkUnstructuredGridBase
| vtkmodules.vtkCommonDataModel.vtkPointSet
| vtkmodules.vtkCommonDataModel.vtkDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, *args, deep: 'bool' = False, validate: 'bool | _NestedMeshValidationFields' = False, **kwargs) -> 'None'
| Initialize the unstructured grid.
|
| __repr__(self)
| Return the standard representation.
|
| __str__(self)
| Return the standard str representation.
|
| cast_to_explicit_structured_grid(self)
| Cast to an explicit structured grid.
|
| Returns
| -------
| pyvista.ExplicitStructuredGrid
| An explicit structured grid.
|
| Raises
| ------
| TypeError
| If the unstructured grid doesn't have the ``'BLOCK_I'``,
| ``'BLOCK_J'`` and ``'BLOCK_K'`` cells arrays.
|
| See Also
| --------
| pyvista.ExplicitStructuredGrid.cast_to_unstructured_grid
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| >>> grid = grid.hide_cells(range(80, 120))
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| >>> grid = grid.cast_to_unstructured_grid()
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| >>> grid = grid.cast_to_explicit_structured_grid()
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| linear_copy(self, deep: 'bool' = False)
| Return a copy of the unstructured grid containing only linear cells.
|
| Converts the following cell types to their linear equivalents.
|
| - :attr:`~pyvista.CellType.QUADRATIC_TRIANGLE` --> :attr:`~pyvista.CellType.TRIANGLE`
| - :attr:`~pyvista.CellType.QUADRATIC_QUAD` --> :attr:`~pyvista.CellType.QUAD`
| - :attr:`~pyvista.CellType.QUADRATIC_TETRA` --> :attr:`~pyvista.CellType.TETRA`
| - :attr:`~pyvista.CellType.QUADRATIC_PYRAMID` --> :attr:`~pyvista.CellType.PYRAMID`
| - :attr:`~pyvista.CellType.QUADRATIC_WEDGE` --> :attr:`~pyvista.CellType.WEDGE`
| - :attr:`~pyvista.CellType.QUADRATIC_HEXAHEDRON` --> :attr:`~pyvista.CellType.HEXAHEDRON`
|
| Parameters
| ----------
| deep : bool, default: False
| When ``True``, makes a copy of the points array.
| Cells and cell types are always copied.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing only linear cells when
| ``deep=False``.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| cell_connectivity
| Return the cell connectivity as a numpy array.
|
| This is effectively :attr:`UnstructuredGrid.cells` without the
| padding.
|
| Returns
| -------
| numpy.ndarray
| Connectivity array.
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Return the cell connectivity for the first two cells.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.cell_connectivity[:16]
| array([ 0, 2, 8, 7, 27, 36, 90, 81, 2, 1, 4, 8, 36, 18, 54, 90])
|
| cells_dict
| Return a dictionary that contains all cells mapped from cell types.
|
| This function returns a :class:`numpy.ndarray` for each cell
| type in an ordered fashion. Note that this function only
| works with element types of fixed sizes.
|
| .. versionchanged:: 0.46
|
| An empty dict ``{}`` is returned instead of ``None`` if
| the input is empty.
|
| Returns
| -------
| dict
| A dictionary mapping containing all cells of this unstructured grid.
| Structure: vtk_enum_type (int) -> cells (:class:`numpy.ndarray`).
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Return the cells dictionary of the sample hex beam. Note how
| there is only one key/value pair as the hex beam example is
| composed of only all hexahedral cells, which is
| ``CellType.HEXAHEDRON``, which evaluates to 12.
|
| Also note how there is no padding for the cell array. This
| approach may be more helpful than the ``cells`` property when
| extracting cells.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.cells_dict # doctest:+SKIP
| {12: array([[ 0, 2, 8, 7, 27, 36, 90, 81],
| [ 2, 1, 4, 8, 36, 18, 54, 90],
| [ 7, 8, 6, 5, 81, 90, 72, 63],
| ...
| [44, 26, 62, 98, 11, 10, 13, 17],
| [89, 98, 80, 71, 16, 17, 15, 14],
| [98, 62, 53, 80, 17, 13, 12, 15]])}
|
| celltypes
| Return the cell types array.
|
| The array contains integer values corresponding to the :attr:`pyvista.Cell.type`
| of each cell in the dataset. See the :class:`pyvista.CellType` enum for more
| information about cell type.
|
| Returns
| -------
| numpy.ndarray
| Array of cell types.
|
| Examples
| --------
| This mesh contains only linear hexahedral cells, type
| :attr:`pyvista.CellType.HEXAHEDRON`, which evaluates to 12.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.celltypes
| array([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
| 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
| 12, 12, 12, 12, 12, 12], dtype=uint8)
|
| Compare this to :attr:`~pyvista.DataSet.distinct_cell_types`.
|
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| face_locations
| Return polyhedron face locations.
|
| .. deprecated:: 0.45.0
| This property is deprecated and will be removed in a future release.
| VTK has deprecated `GetFaces` and `GetFaceLocations` in VTK 9.4 and
| may be removed in a future release of VTK. Please use
| `polyhedral_face_locations` instead.
|
| Returns
| -------
| numpy.ndarray
| Array of face locations.
|
| faces
| Return the polyhedron faces.
|
| .. deprecated:: 0.45.0
| This property is deprecated and will be removed in a future release.
| VTK has deprecated `GetFaces` and `GetFaceLocations` in VTK 9.4 and
| may be removed in a future release of VTK. Please use
| `polyhedral_faces` instead.
|
| Returns
| -------
| numpy.ndarray
| Array of faces.
|
| offset
| Return the cell locations array.
|
| This is the location of the start of each cell in
| :attr:`cell_connectivity`.
|
| Returns
| -------
| numpy.ndarray
| Array of cell offsets indicating the start of each cell.
|
| Notes
| -----
| The array returned is immutable and cannot be written to. If you
| need to modify this array, create a copy of it using
| :func:`numpy.copy`.
|
| Examples
| --------
| Return the cell offset array. Since this mesh is composed of
| all hexahedral cells, note how each cell starts at 8 greater
| than the prior cell.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.offset
| array([ 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96,
| 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200,
| 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 288, 296, 304,
| 312, 320])
|
| polyhedron_face_locations
| Return the polyhedron face locations.
|
| Returns
| -------
| numpy.ndarray
| Array of faces.
|
| polyhedron_faces
| Return the polyhedron faces.
|
| Returns
| -------
| numpy.ndarray
| Array of faces.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| cells
| Return the cell data as a numpy object.
|
| This is the old style VTK data layout::
|
| [n0, p0_0, p0_1, ..., p0_n, n1, p1_0, p1_1, ..., p1_n, ...]
|
| where ``n0`` is the number of points in cell 0, and ``pX_Y`` is the
| Y'th point in cell X.
|
| For example, a triangle and a line might be represented as::
|
| [3, 0, 1, 2, 2, 0, 1]
|
| Where the two individual cells would be ``[3, 0, 1, 2]`` and ``[2, 0, 1]``.
|
| See Also
| --------
| pyvista.DataSet.get_cell
| pyvista.UnstructuredGrid.cell_connectivity
| pyvista.UnstructuredGrid.offset
|
| Notes
| -----
| The array returned cannot be modified in place and will raise a
| ``ValueError`` if attempted.
|
| You can, however, set the cells directly. See the example.
|
| Examples
| --------
| Return the indices of the first two cells from the example hex
| beam. Note how the cells have "padding" indicating the number
| of points per cell.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.cells[:18]
| array([ 8, 0, 2, 8, 7, 27, 36, 90, 81, 8, 2, 1, 4, 8, 36, 18, 54,
| 90])
|
| While you cannot change the array inplace, you can overwrite it. For example:
|
| >>> grid.cells = [8, 0, 1, 2, 3, 4, 5, 6, 7]
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| ----------------------------------------------------------------------
| Methods inherited from PointGrid:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| plot_curvature(self: 'Self', curv_type='mean', **kwargs)
| Plot the curvature of the external surface of the grid.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| One of the following strings indicating curvature types.
| - ``'mean'``
| - ``'gaussian'``
| - ``'maximum'``
| - ``'minimum'``
|
| **kwargs : dict, optional
| Optional keyword arguments. See :func:`pyvista.plot`.
|
| Returns
| -------
| list
| Camera position, focal point, and view up. Returned when
| ``return_cpos`` is ``True``.
|
| ----------------------------------------------------------------------
| Methods inherited from _PointSet:
|
| center_of_mass(self, scalars_weight: 'bool' = False) -> 'NumpyArray[float]'
| Return the coordinates for the center of mass of the mesh.
|
| Parameters
| ----------
| scalars_weight : bool, default: False
| Flag for using the mesh scalars as weights.
|
| Returns
| -------
| numpy.ndarray
| Coordinates for the center of mass.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 1, 1))
| >>> mesh.center_of_mass()
| array([1., 1., 1.])
|
| points_to_double(self) -> 'Self'
| Convert the points datatype to double precision.
|
| Returns
| -------
| pyvista.PointSet
| Pointset with points in double precision.
|
| Notes
| -----
| This operates in place.
|
| Examples
| --------
| Create a mesh that has points of the type ``float32`` and
| convert the points to ``float64``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.points.dtype
| dtype('float32')
| >>> _ = mesh.points_to_double()
| >>> mesh.points.dtype
| dtype('float64')
|
| remove_cells(self, ind: 'VectorLike[bool] | VectorLike[int]', inplace: 'bool' = False) -> '_PointSet'
| Remove cells.
|
| Parameters
| ----------
| ind : VectorLike[int] | VectorLike[bool]
| Cell indices to be removed. The array can also be a
| boolean array of the same size as the number of cells.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| Returns
| -------
| pyvista.DataSet
| Same type as the input, but with the specified cells
| removed.
|
| See Also
| --------
| :ref:`ghost_cells_example`
|
| Examples
| --------
| Remove 20 cells from an unstructured grid.
|
| >>> from pyvista import examples
| >>> import pyvista as pv
| >>> hex_mesh = pv.read(examples.hexbeamfile)
| >>> removed = hex_mesh.remove_cells(range(10, 20))
| >>> removed.plot(color='lightblue', show_edges=True, line_width=3)
|
| shallow_copy(self, to_copy: 'DataSet') -> 'None'
| Create a shallow copy from a different dataset into this one.
|
| This method mutates this dataset and returns ``None``.
|
| Parameters
| ----------
| to_copy : pyvista.DataSet
| Data object to perform the shallow copy from.
|
| translate(self: 'Self', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False)
| Translate the mesh.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats of cartesian values to translate the mesh with.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed. This is
| only valid when not updating in place.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PointSet
| Translated pointset.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=True)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.unstructured_grid.UnstructuredGridFilters:
|
| clean(self, tolerance=0, remove_unused_points: 'bool' = True, produce_merge_map: 'bool' = True, average_point_data: 'bool' = True, merging_array_name=None, progress_bar: 'bool' = False)
| Merge duplicate points and remove unused points in an UnstructuredGrid.
|
| This filter, merging coincident points as defined by a merging
| tolerance and optionally removes unused points. The filter does not
| modify the topology of the input dataset, nor change the types of
| cells. It may however, renumber the cell connectivity ids.
|
| This filter implements :vtk:`vtkStaticCleanUnstructuredGrid`.
|
| Parameters
| ----------
| tolerance : float, default: 0.0
| The absolute point merging tolerance.
|
| remove_unused_points : bool, default: True
| Indicate whether points unused by any cell are removed from the
| output. Note that when this is off, the filter can successfully
| process datasets with no cells (and just points). If on in this
| case, and there are no cells, the output will be empty.
|
| produce_merge_map : bool, default: False
| Indicate whether a merge map should be produced on output.
| The merge map, if requested, maps each input point to its
| output point id, or provides a value of -1 if the input point
| is not used in the output. The merge map is associated with
| the filter's output field data and is named ``"PointMergeMap"``.
|
| average_point_data : bool, default: True
| Indicate whether point coordinates and point data of merged points
| are averaged. When ``True``, the data coordinates and attribute
| values of all merged points are averaged. When ``False``, the point
| coordinate and data of the single remaining merged point is
| retained.
|
| merging_array_name : str, optional
| If a ``merging_array_name`` is specified and exists in the
| ``point_data``, then point merging will switch into a mode where
| merged points must be both geometrically coincident and have
| matching point data. When set, ``tolerance`` has no effect.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Cleaned unstructured grid.
|
| See Also
| --------
| remove_unused_points
| Strictly remove unused points `without` merging points.
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Demonstrate cleaning an UnstructuredGrid and show how it can be used to
| average the point data across merged points.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hexbeam = examples.load_hexbeam()
| >>> hexbeam_shifted = hexbeam.translate([1, 0, 0])
| >>> hexbeam.point_data['data'] = [0] * hexbeam.n_points
| >>> hexbeam_shifted.point_data['data'] = [1] * hexbeam.n_points
| >>> merged = hexbeam.merge(hexbeam_shifted, merge_points=False)
| >>> cleaned = merged.clean(average_point_data=True)
| >>> cleaned.n_points < merged.n_points
| True
|
| Show how point averaging using the ``clean`` method with
| ``average_point_data=True`` results in averaged point data for merged
| points.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(merged, scalars='data', show_scalar_bar=False)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cleaned, scalars='data')
| >>> pl.show()
|
| delaunay_2d(self, tol=1e-05, alpha=0.0, offset=1.0, bound: 'bool' = False, inplace: 'bool' = False, edge_source=None, progress_bar: 'bool' = False) from pyvista.core.filters.poly_data.PolyDataFilters
| Apply a 2D Delaunay filter along the best fitting plane.
|
| This filter can be used to generate a 2d surface from a set of
| points on a plane. If you want to create a surface from a
| point cloud, see :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| tol : float, default: 1e-05
| Specify a tolerance to control discarding of closely
| spaced points. This tolerance is specified as a fraction
| of the diagonal length of the bounding box of the points.
|
| alpha : float, default: 0.0
| Specify alpha (or distance) value to control output of
| this filter. For a non-zero alpha value, only edges or
| triangles contained within a sphere centered at mesh
| vertices will be output. Otherwise, only triangles will be
| output.
|
| offset : float, default: 1.0
| Specify a multiplier to control the size of the initial,
| bounding Delaunay triangulation.
|
| bound : bool, default: False
| Boolean controls whether bounding triangulation points
| and associated triangles are included in the
| output. These are introduced as an initial triangulation
| to begin the triangulation process. This feature is nice
| for debugging output.
|
| inplace : bool, default: False
| If ``True``, overwrite this mesh with the triangulated
| mesh.
|
| edge_source : pyvista.PolyData, optional
| Specify the source object used to specify constrained
| edges and loops. If set, and lines/polygons are defined, a
| constrained triangulation is created. The lines/polygons
| are assumed to reference points in the input point set
| (i.e. point ids are identical in the input and
| source).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh from the 2D delaunay filter.
|
| Examples
| --------
| First, generate 30 points on circle and plot them.
|
| >>> import pyvista as pv
| >>> points = pv.Polygon(n_sides=30).points
| >>> circle = pv.PolyData(points)
| >>> circle.plot(show_edges=True, point_size=15)
|
| Use :func:`delaunay_2d` to fill the interior of the circle.
|
| >>> filled_circle = circle.delaunay_2d()
| >>> filled_circle.plot(show_edges=True, line_width=5)
|
| Use the ``edge_source`` parameter to create a constrained delaunay
| triangulation and plot it.
|
| >>> squar = pv.Polygon(n_sides=4, radius=8, fill=False)
| >>> squar = squar.rotate_z(45, inplace=False)
| >>> circ0 = pv.Polygon(center=(2, 3, 0), n_sides=30, radius=1)
| >>> circ1 = pv.Polygon(center=(-2, -3, 0), n_sides=30, radius=1)
| >>> comb = circ0.append_polydata(circ1, squar)
| >>> tess = comb.delaunay_2d(edge_source=comb)
| >>> tess.plot(cpos='xy', show_edges=True)
|
| See :ref:`create_tri_surface_example` for more examples using this filter.
|
| reconstruct_surface(self, nbr_sz=None, sample_spacing=None, progress_bar: 'bool' = False) from pyvista.core.filters.poly_data.PolyDataFilters
| Reconstruct a surface from the points in this dataset.
|
| This filter takes a list of points assumed to lie on the
| surface of a solid 3D object. A signed measure of the distance
| to the surface is computed and sampled on a regular grid. The
| grid can then be contoured at zero to extract the surface. The
| default values for neighborhood size and sample spacing should
| give reasonable results for most uses but can be set if
| desired.
|
| This is helpful when generating surfaces from point clouds and
| is more reliable than :func:`DataSetFilters.delaunay_3d`.
|
| Parameters
| ----------
| nbr_sz : int, optional
| Specify the number of neighbors each point has, used for
| estimating the local surface orientation.
|
| The default value of 20 should be fine for most
| applications, higher values can be specified if the spread
| of points is uneven. Values as low as 10 may yield
| adequate results for some surfaces. Higher values cause
| the algorithm to take longer and will cause
| errors on sharp boundaries.
|
| sample_spacing : float, optional
| The spacing of the 3D sampling grid. If not set, a
| reasonable guess will be made.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Reconstructed surface.
|
| Examples
| --------
| Create a point cloud out of a sphere and reconstruct a surface
| from it.
|
| >>> import pyvista as pv
| >>> points = pv.wrap(pv.Sphere().points)
| >>> surf = points.reconstruct_surface()
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(points)
| >>> _ = pl.add_title('Point Cloud of 3D Surface')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(surf, color=True, show_edges=True)
| >>> _ = pl.add_title('Reconstructed Surface')
| >>> pl.show()
|
| See :ref:`surface_reconstruction_example` for more examples
| using this filter.
|
| remove_unused_points(self: '_UnstructuredGridType', *, inplace: 'bool' = False) -> '_UnstructuredGridType'
| Remove points which are not used by any cells.
|
| Unlike :meth:`clean`, this filter does `not` merge points.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy is returned.
|
| See Also
| --------
| pyvista.PolyDataFilters.remove_unused_points
|
| Returns
| -------
| UnstructuredGrid
| Mesh with unused points removed.
|
| Examples
| --------
| Create :class:`~pyvista.UnstructuredGrid` with three points. The first two points are
| coincident and associated with :attr:`~pyvista.CellType.VERTEX` cells, and the third point
| is "unused" and not associated with any cells.
|
| >>> import pyvista as pv
| >>> cells = [1, 0, 1, 1]
| >>> celltypes = [pv.CellType.VERTEX, pv.CellType.VERTEX]
| >>> points = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]
| >>> grid = pv.UnstructuredGrid(cells, celltypes, points)
| >>> grid
| UnstructuredGrid (...)
| N Cells: 2
| N Points: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 1.000e+00
| N Arrays: 0
|
| Since the third point is unused, we can remove it. Note that coincident points are `not`
| merged by this filter, so the two vertex points are kept as-is.
|
| >>> grid = grid.remove_unused_points()
| >>> grid
| UnstructuredGrid (...)
| N Cells: 2
| N Points: 2
| X Bounds: 0.000e+00, 0.000e+00
| Y Bounds: 0.000e+00, 0.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| N Arrays: 0
|
| subdivide_tetra(self)
| Subdivide each tetrahedron into twelve tetrahedrons.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the subdivided tetrahedrons.
|
| Examples
| --------
| First, load a sample tetrahedral UnstructuredGrid and plot it.
|
| >>> from pyvista import examples
| >>> grid = examples.load_tetbeam()
| >>> grid.plot(show_edges=True, line_width=2)
|
| Now, subdivide and plot.
|
| >>> subdivided = grid.subdivide_tetra()
| >>> subdivided.plot(show_edges=True, line_width=2)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkUnstructuredGrid:
|
| AddReferenceToCell(...)
| AddReferenceToCell(self, ptId:int, cellId:int) -> None
| C++: void AddReferenceToCell(vtkIdType ptId, vtkIdType cellId)
|
| Allocate(...)
| Allocate(self, numCells:int=1000, extSize:int=1000) -> None
| C++: void Allocate(vtkIdType numCells=1000, int extSize=1000)
| override;
|
| Method allocates initial storage for the cell connectivity. Use
| this method before the method InsertNextCell(). The array
| capacity is doubled when the inserting a cell exceeds the current
| capacity. extSize is no longer used.
|
| ote Prefer AllocateExact or AllocateEstimate, which give more
| control over how allocations are distributed.
|
| AllocateEstimate(...)
| AllocateEstimate(self, numCells:int, maxCellSize:int) -> bool
| C++: bool AllocateEstimate(vtkIdType numCells,
| vtkIdType maxCellSize)
|
| Pre-allocate memory in internal data structures. Does not change
| the number of cells, only the array capacities. Existing data is
| NOT preserved.
| @param numCells The number of expected cells in the dataset.
| @param maxCellSize The number of points per cell to allocate
| memory for.
| @return True if allocation succeeds.
| @sa Squeeze();
|
| AllocateExact(...)
| AllocateExact(self, numCells:int, connectivitySize:int) -> bool
| C++: bool AllocateExact(vtkIdType numCells,
| vtkIdType connectivitySize)
|
| Pre-allocate memory in internal data structures. Does not change
| the number of cells, only the array capacities. Existing data is
| NOT preserved.
| @param numCells The number of expected cells in the dataset.
| @param connectivitySize The total number of pointIds stored for
| all cells.
| @return True if allocation succeeds.
| @sa Squeeze();
|
| BuildLinks(...)
| BuildLinks(self) -> None
| C++: void BuildLinks()
|
| Build topological links from points to lists of cells that use
| each point. See vtkAbstractCellLinks for more information.
|
| ConvertFaceStreamPointIds(...)
| ConvertFaceStreamPointIds(faceStream:vtkIdList, idMap:[int, ...])
| -> None
| C++: static void ConvertFaceStreamPointIds(vtkIdList *faceStream,
| vtkIdType *idMap)
| ConvertFaceStreamPointIds(nfaces:int, faceStream:[int, ...],
| idMap:[int, ...]) -> None
| C++: static void ConvertFaceStreamPointIds(vtkIdType nfaces,
| vtkIdType *faceStream, vtkIdType *idMap)
| ConvertFaceStreamPointIds(faces:vtkCellArray, idMap:[int, ...])
| -> None
| C++: static void ConvertFaceStreamPointIds(vtkCellArray *faces,
| vtkIdType *idMap)
|
| Convert pid in a face stream into idMap[pid]. The face stream is
| of format [nCellFaces, nFace0Pts, i, j, k, nFace1Pts, i, j, k,
| ...]. The user is responsible to make sure all the Ids in
| faceStream do not exceed the range of idMap.
|
| CopyStructure(...)
| CopyStructure(self, ds:vtkDataSet) -> None
| C++: void CopyStructure(vtkDataSet *ds) override;
|
| Copy the geometric structure of an input point set object.
|
| DecomposeAPolyhedronCell(...)
| DecomposeAPolyhedronCell(polyhedronCellArray:vtkCellArray,
| nCellpts:int, nCellfaces:int, cellArray:vtkCellArray,
| faces:vtkIdTypeArray) -> None
| C++: static void DecomposeAPolyhedronCell(
| vtkCellArray *polyhedronCellArray, vtkIdType &nCellpts,
| vtkIdType &nCellfaces, vtkCellArray *cellArray,
| vtkIdTypeArray *faces)
| DecomposeAPolyhedronCell(polyhedronCellStream:(int, ...),
| nCellpts:int, nCellfaces:int, cellArray:vtkCellArray,
| faces:vtkIdTypeArray) -> None
| C++: static void DecomposeAPolyhedronCell(
| const vtkIdType *polyhedronCellStream, vtkIdType &nCellpts,
| vtkIdType &nCellfaces, vtkCellArray *cellArray,
| vtkIdTypeArray *faces)
| DecomposeAPolyhedronCell(nCellFaces:int, inFaceStream:(int, ...),
| nCellpts:int, cellArray:vtkCellArray, faces:vtkIdTypeArray)
| -> None
| C++: static void DecomposeAPolyhedronCell(vtkIdType nCellFaces,
| const vtkIdType *inFaceStream, vtkIdType &nCellpts,
| vtkCellArray *cellArray, vtkIdTypeArray *faces)
|
| A static method for converting a polyhedron vtkCellArray of
| format [nCellFaces, nFace0Pts, i, j, k, nFace1Pts, i, j, k, ...]
| into three components: (1) an integer indicating the number of
| faces (2) a standard vtkCellArray storing point ids [nCell0Pts,
| i, j, k] and (3) an vtkIdTypeArray storing face connectivity in
| format [nFace0Pts, i, j, k, nFace1Pts, i, j, k, ...] Note: input
| is assumed to contain only one polyhedron cell. Outputs (2) and
| (3) will be stacked at the end of the input cellArray and faces.
| The original data in the input will not be touched.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| ExtendedNew(...)
| ExtendedNew() -> vtkUnstructuredGrid
| C++: static vtkUnstructuredGrid *ExtendedNew()
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated. The
| memory size returned is guaranteed to be greater than or equal to
| the memory required to represent the data (e.g., extra space in
| arrays, etc. are not included in the return value). THIS METHOD
| IS THREAD SAFE.
|
| GetCell(...)
| GetCell(self, cellId:int) -> vtkCell
| C++: vtkCell *GetCell(vtkIdType cellId) override;
| GetCell(self, cellId:int, cell:vtkGenericCell) -> None
| C++: void GetCell(vtkIdType cellId, vtkGenericCell *cell)
| override;
| GetCell(self, i:int, j:int, k:int) -> vtkCell
| C++: virtual vtkCell *GetCell(int i, int j, int k)
|
| This method always return a `vtkEmptyCell`, as there is no cell
| in a `vtkPointSet`.
|
| GetCellBounds(...)
| GetCellBounds(self, cellId:int, bounds:[float, float, float,
| float, float, float]) -> None
| C++: void GetCellBounds(vtkIdType cellId, double bounds[6])
| override;
|
| Get the bounds of the cell with cellId such that: 0 <= cellId <
| NumberOfCells. A subclass may be able to determine the bounds of
| cell without using an expensive GetCell() method. A default
| implementation is provided that actually uses a GetCell() call.
| This is to ensure the method is available to all datasets.
| Subclasses should override this method to provide an efficient
| implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetCellLocationsArray(...)
| GetCellLocationsArray(self) -> vtkIdTypeArray
| C++: vtkIdTypeArray *GetCellLocationsArray()
|
| Get the array of all the starting indices of cell definitions in
| the cell array.
|
| @warning vtkCellArray supports random access now. This array is
| no
| longer used.
|
| GetCellNeighbors(...)
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds) override;
| GetCellNeighbors(self, cellId:int, npts:int, ptIds:(int, ...),
| cellIds:vtkIdList) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdType npts,
| const vtkIdType *ptIds, vtkIdList *cellIds)
|
| A topological inquiry to retrieve all of the cells using list of
| points exclusive of the current cell specified (e.g., cellId).
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED.
|
| GetCellNumberOfFaces(...)
| GetCellNumberOfFaces(self, cellId:int, cellType:int,
| cell:vtkGenericCell) -> int
| C++: int GetCellNumberOfFaces(vtkIdType cellId,
| unsigned char &cellType, vtkGenericCell *cell) override;
|
| Get the number of faces of a cell.
|
| Most of the times extracting the number of faces requires only
| extracting the cell type. However, for some cell types, the
| number of faces is not constant. For example, a convex point set
| cell can have a different number of faces for each cell. That's
| why this method requires the cell id and the dataset.
|
| GetCellPoints(...)
| GetCellPoints(self, cellId:int, ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
| override;
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...)) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts)
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...),
| ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts, vtkIdList *ptIds) override;
|
| Topological inquiry to get points defining cell. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| GetCellSize(...)
| GetCellSize(self, cellId:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType cellId) override;
|
| Get the size of the cell with given cellId.
|
| GetCellType(...)
| GetCellType(self, cellId:int) -> int
| C++: int GetCellType(vtkIdType cellId) override;
|
| Get the type of the cell with the given cellId.
|
| GetCellTypes(...)
| GetCellTypes(self, types:vtkCellTypes) -> None
| C++: void GetCellTypes(vtkCellTypes *types) override;
| GetCellTypes(self) -> vtkDataArray
| C++: vtkDataArray *GetCellTypes()
|
| GetCellTypesArray(...)
| GetCellTypesArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellTypesArray()
|
| GetCells(...)
| GetCells(self) -> vtkCellArray
| C++: vtkCellArray *GetCells()
|
| Return the unstructured grid connectivity array.
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkUnstructuredGrid
| C++: static vtkUnstructuredGrid *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkUnstructuredGrid
| C++: static vtkUnstructuredGrid *GetData(vtkInformationVector *v,
| int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Standard vtkDataSet API methods. See vtkDataSet for more
| information.
|
| GetDistinctCellTypes(...)
| GetDistinctCellTypes(self, types:vtkCellTypes) -> None
| C++: void GetDistinctCellTypes(vtkCellTypes *types) override;
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset with 5 triangles, 3 lines,
| and 100 hexahedra would result in a list of three entries,
| corresponding to the types VTK_TRIANGLE, VTK_LINE, and
| VTK_HEXAHEDRON. This override implements an optimization that
| recomputes cell types only when the types of cells may have
| changed.
|
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetDistinctCellTypesArray(...)
| GetDistinctCellTypesArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetDistinctCellTypesArray()
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset with 5 triangles, 3 lines,
| and 100 hexahedra would result in a list of three entries,
| corresponding to the types VTK_TRIANGLE, VTK_LINE, and
| VTK_HEXAHEDRON. This override implements an optimization that
| recomputes cell types only when the types of cells may have
| changed. This method never returns `nullptr`.
|
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetFaceStream(...)
| GetFaceStream(self, cellId:int, ptIds:vtkIdList) -> None
| C++: void GetFaceStream(vtkIdType cellId, vtkIdList *ptIds)
|
| Get the face stream of a polyhedron cell in the following format:
| (numCellFaces, numFace0Pts, id1, id2, id3, numFace1Pts,id1, id2,
| id3, ...). If the requested cell is not a polyhedron, then the
| standard GetCellPoints is called to return a list of unique point
| ids (id1, id2, id3, ...). This function is threadsafe.
|
| GetGhostLevel(...)
| GetGhostLevel(self) -> int
| C++: virtual int GetGhostLevel()
|
| Get the ghost level.
|
| GetIdsOfCellsOfType(...)
| GetIdsOfCellsOfType(self, type:int, array:vtkIdTypeArray) -> None
| C++: void GetIdsOfCellsOfType(int type, vtkIdTypeArray *array)
| override;
|
| Fill vtkIdTypeArray container with list of cell Ids. This method
| traverses all cells and, for a particular cell type, inserts the
| cell Id into the container.
|
| GetLinks(...)
| GetLinks(self) -> vtkAbstractCellLinks
| C++: virtual vtkAbstractCellLinks *GetLinks()
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Get the size, in number of points, of the largest cell.
|
| GetMaxSpatialDimension(...)
| GetMaxSpatialDimension(self) -> int
| C++: int GetMaxSpatialDimension() override;
|
| Get the maximum/minimum spatial dimensionality of the data which
| is the maximum/minimum dimension of all cells.
|
| GetMeshMTime(...)
| GetMeshMTime(self) -> int
| C++: vtkMTimeType GetMeshMTime() override;
|
| Return the mesh (geometry/topology) modification time. This time
| is different from the usual MTime which also takes into account
| the modification of data arrays. This function can be used to
| track the changes on the mesh separately from the data arrays
| (eg. static mesh over time with transient data).
|
| GetMinSpatialDimension(...)
| GetMinSpatialDimension(self) -> int
| C++: int GetMinSpatialDimension() override;
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| This method always returns 0, as there are no cells in a
| `vtkPointSet`.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfPieces(...)
| GetNumberOfPieces(self) -> int
| C++: virtual int GetNumberOfPieces()
|
| GetPiece(...)
| GetPiece(self) -> int
| C++: virtual int GetPiece()
|
| Set / Get the piece and the number of pieces. Similar to extent
| in 3D.
|
| GetPointCells(...)
| GetPointCells(self, ptId:int, cellIds:vtkIdList) -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
| override;
| GetPointCells(self, ptId:int, ncells:int, cells:[int, ...])
| -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdType &ncells,
| vtkIdType *&cells)
|
| Topological inquiry to get cells using point. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| GetPolyhedronFaceLocations(...)
| GetPolyhedronFaceLocations(self) -> vtkCellArray
| C++: vtkCellArray *GetPolyhedronFaceLocations()
|
| GetPolyhedronFaces(...)
| GetPolyhedronFaces(self, cellId:int, faces:vtkCellArray) -> None
| C++: void GetPolyhedronFaces(vtkIdType cellId,
| vtkCellArray *faces)
| GetPolyhedronFaces(self) -> vtkCellArray
| C++: vtkCellArray *GetPolyhedronFaces()
|
| Special support for polyhedron. Do not handle all other cell
| types.
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Reset the grid to an empty state and free any memory.
|
| InitializeFacesRepresentation(...)
| InitializeFacesRepresentation(self, numPrevCells:int) -> int
| C++: int InitializeFacesRepresentation(vtkIdType numPrevCells)
|
| Special function used by vtkUnstructuredGridReader. By default
| vtkUnstructuredGrid does not contain face information, which is
| only used by polyhedron cells. If so far no polyhedron cells have
| been added, Faces and FaceLocations pointers will be nullptr. In
| this case, need to initialize the arrays and assign values to the
| previous non-polyhedron cells.
|
| InsertNextLinkedCell(...)
| InsertNextLinkedCell(self, type:int, npts:int, pts:(int, ...))
| -> int
| C++: vtkIdType InsertNextLinkedCell(int type, int npts,
| const vtkIdType pts[])
|
| Use these methods only if the dataset has been specified as
| Editable. See vtkPointSet for more information.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsCellBoundary(...)
| IsCellBoundary(self, cellId:int, npts:int, ptIds:(int, ...),
| neighborCellId:int) -> bool
| C++: bool IsCellBoundary(vtkIdType cellId, vtkIdType npts,
| const vtkIdType *ptIds, vtkIdType &neighborCellId)
| IsCellBoundary(self, cellId:int, npts:int, ptIds:(int, ...))
| -> bool
| C++: bool IsCellBoundary(vtkIdType cellId, vtkIdType npts,
| const vtkIdType *ptIds)
|
| A topological inquiry to determine whether a topological entity
| (e.g., point, edge, or face) defined by the point ids (ptIds of
| length npts) is a boundary entity of a specified cell (indicated
| by cellId). A boundary entity is a topological feature used by
| exactly one cell. This method is related to GetCellNeighbors()
| except that it simply indicates whether a topological feature is
| boundary - hence the method is faster. THIS METHOD IS THREAD SAFE
| IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT
| MODIFIED.
|
| IsHomogeneous(...)
| IsHomogeneous(self) -> int
| C++: int IsHomogeneous() override;
|
| Returns whether cells are all of the same type.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewCellIterator(...)
| NewCellIterator(self) -> vtkCellIterator
| C++: vtkCellIterator *NewCellIterator() override;
|
| Return an iterator that traverses the cells in this data set.
|
| NewInstance(...)
| NewInstance(self) -> vtkUnstructuredGrid
| C++: vtkUnstructuredGrid *NewInstance()
|
| RemoveGhostCells(...)
| RemoveGhostCells(self) -> None
| C++: void RemoveGhostCells()
|
| This method will remove any cell that is marked as ghost (has the
| vtkDataSetAttributes::DUPLICATECELL or the
| vtkDataSetAttributes::HIDDENCELL bit set).
|
| RemoveReferenceToCell(...)
| RemoveReferenceToCell(self, ptId:int, cellId:int) -> None
| C++: void RemoveReferenceToCell(vtkIdType ptId, vtkIdType cellId)
|
| Reset(...)
| Reset(self) -> None
| C++: void Reset()
|
| Standard vtkDataSet methods; see vtkDataSet.h for documentation.
|
| ResizeCellList(...)
| ResizeCellList(self, ptId:int, size:int) -> None
| C++: void ResizeCellList(vtkIdType ptId, int size)
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkUnstructuredGrid
| C++: static vtkUnstructuredGrid *SafeDownCast(vtkObjectBase *o)
|
| SetCells(...)
| SetCells(self, type:int, cells:vtkCellArray) -> None
| C++: void SetCells(int type, vtkCellArray *cells)
| SetCells(self, types:[int, ...], cells:vtkCellArray) -> None
| C++: void SetCells(int *types, vtkCellArray *cells)
| SetCells(self, cellTypes:vtkDataArray, cells:vtkCellArray) -> None
| C++: void SetCells(vtkDataArray *cellTypes, vtkCellArray *cells)
| SetCells(self, cellTypes:vtkUnsignedCharArray, cells:vtkCellArray,
| faceLocations:vtkIdTypeArray, faces:vtkIdTypeArray) -> None
| C++: void SetCells(vtkUnsignedCharArray *cellTypes,
| vtkCellArray *cells, vtkIdTypeArray *faceLocations,
| vtkIdTypeArray *faces)
| SetCells(self, cellTypes:vtkUnsignedCharArray,
| cellLocations:vtkIdTypeArray, cells:vtkCellArray) -> None
| C++: void SetCells(vtkUnsignedCharArray *cellTypes,
| vtkIdTypeArray *cellLocations, vtkCellArray *cells)
| SetCells(self, cellTypes:vtkUnsignedCharArray,
| cellLocations:vtkIdTypeArray, cells:vtkCellArray,
| faceLocations:vtkIdTypeArray, faces:vtkIdTypeArray) -> None
| C++: void SetCells(vtkUnsignedCharArray *cellTypes,
| vtkIdTypeArray *cellLocations, vtkCellArray *cells,
| vtkIdTypeArray *faceLocations, vtkIdTypeArray *faces)
|
| Provide cell information to define the dataset with a single
| type.
|
| ote This method will create a vtkConstantArray<unsigned char> for
| the cell types internally to save memory. Therefore, if extracted
| via GetCellTypes(), it should NOT be assumed that it is a
| vtkUnsignedCharArray.
|
| SetLinks(...)
| SetLinks(self, _arg:vtkAbstractCellLinks) -> None
| C++: virtual void SetLinks(vtkAbstractCellLinks *_arg)
|
| Set/Get the links that you created possibly without using
| BuildLinks.
|
| SetPolyhedralCells(...)
| SetPolyhedralCells(self, cellTypes:vtkDataArray,
| cells:vtkCellArray, faceLocations:vtkCellArray,
| faces:vtkCellArray) -> None
| C++: void SetPolyhedralCells(vtkDataArray *cellTypes,
| vtkCellArray *cells, vtkCellArray *faceLocations,
| vtkCellArray *faces)
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: void Squeeze() override;
|
| Squeeze all arrays in the grid to conserve memory.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkUnstructuredGrid:
|
| __this__
| Pointer to the C++ object.
|
| cell_locations_array
| read-only, calls GetCellLocationsArray
|
| cell_types
| read-only, calls GetCellTypes
|
| cell_types_array
| read-only, calls GetCellTypesArray
|
| data_object_type
| read-only, calls GetDataObjectType
|
| distinct_cell_types_array
| read-only, calls GetDistinctCellTypesArray
|
| ghost_level
| read-only, calls GetGhostLevel
|
| links
| read-write, calls GetLinks/SetLinks
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| max_spatial_dimension
| read-only, calls GetMaxSpatialDimension
|
| mesh_m_time
| read-only, calls GetMeshMTime
|
| min_spatial_dimension
| read-only, calls GetMinSpatialDimension
|
| number_of_pieces
| read-only, calls GetNumberOfPieces
|
| piece
| read-only, calls GetPiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkUnstructuredGrid:
|
| __vtkname__ = 'vtkUnstructuredGrid'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkUnstructuredGridBase:
|
| InsertNextCell(...)
| InsertNextCell(self, type:int, npts:int, ptIds:(int, ...)) -> int
| C++: vtkIdType InsertNextCell(int type, vtkIdType npts,
| const vtkIdType ptIds[])
| InsertNextCell(self, type:int, ptIds:vtkIdList) -> int
| C++: vtkIdType InsertNextCell(int type, vtkIdList *ptIds)
| InsertNextCell(self, type:int, npts:int, ptIds:(int, ...),
| nfaces:int, faces:(int, ...)) -> int
| C++: vtkIdType InsertNextCell(int type, vtkIdType npts,
| const vtkIdType ptIds[], vtkIdType nfaces,
| const vtkIdType faces[])
| InsertNextCell(self, type:int, npts:int, ptIds:(int, ...),
| faces:vtkCellArray) -> int
| C++: vtkIdType InsertNextCell(int type, vtkIdType npts,
| const vtkIdType ptIds[], vtkCellArray *faces)
|
| Insert/create cell in object by type and list of point ids
| defining cell topology. Most cells require just a type which
| implicitly defines a set of points and their ordering. For
| non-polyhedron cell type, npts is the number of unique points in
| the cell. pts are the list of global point Ids. For polyhedron
| cell, a special input format is required. npts is the number of
| faces in the cell. ptIds is the list of face stream:
| (numFace0Pts, id1, id2, id3, numFace1Pts,id1, id2, id3, ...) Make
| sure you have called Allocate() before calling this method
|
| ReplaceCell(...)
| ReplaceCell(self, cellId:int, npts:int, pts:(int, ...)) -> None
| C++: void ReplaceCell(vtkIdType cellId, int npts,
| const vtkIdType pts[])
|
| Replace the points defining cell "cellId" with a new set of
| points. This operator is (typically) used when links from points
| to cells have not been built (i.e., BuildLinks() has not been
| executed). Use the operator ReplaceLinkedCell() to replace a cell
| when cell structure has been built.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| BuildCellLocator(...)
| BuildCellLocator(self) -> None
| C++: void BuildCellLocator()
|
| Build the cell locator. In a multi-threaded environment, call
| this method in a single thread before using FindCell().
|
| BuildLocator(...)
| BuildLocator(self) -> None
| C++: void BuildLocator()
|
| BuildPointLocator(...)
| BuildPointLocator(self) -> None
| C++: void BuildPointLocator()
|
| Build the internal point locator . In a multi-threaded
| environment, call this method in a single thread before using
| FindCell() or FindPoint().
|
| ComputeBounds(...)
| ComputeBounds(self) -> None
| C++: void ComputeBounds() override;
|
| Compute the (X, Y, Z) bounds of the data.
|
| EditableOff(...)
| EditableOff(self) -> None
| C++: virtual void EditableOff()
|
| EditableOn(...)
| EditableOn(self) -> None
| C++: virtual void EditableOn()
|
| FindCell(...)
| FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int,
| tol2:float, subId:int, pcoords:[float, float, float],
| weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
| FindCell(self, x:[float, float, float], cell:vtkCell,
| gencell:vtkGenericCell, cellId:int, tol2:float, subId:int,
| pcoords:[float, float, float], weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkGenericCell *gencell, vtkIdType cellId, double tol2,
| int &subId, double pcoords[3], double *weights) override;
|
| Locate cell based on global coordinate x and tolerance squared.
| If cell and cellId is non-nullptr, then search starts from this
| cell and looks at immediate neighbors. Returns cellId >= 0 if
| inside, < 0 otherwise. The parametric coordinates are provided
| in pcoords[3]. The interpolation weights are returned in
| weights[]. (The number of weights is equal to the number of
| points in the found cell). Tolerance is used to control how close
| the point is to be considered "in" the cell. THIS METHOD IS NOT
| THREAD SAFE.
|
| FindPoint(...)
| FindPoint(self, x:[float, float, float]) -> int
| C++: vtkIdType FindPoint(double x[3]) override;
|
| GetCellLocator(...)
| GetCellLocator(self) -> vtkAbstractCellLocator
| C++: virtual vtkAbstractCellLocator *GetCellLocator()
|
| GetEditable(...)
| GetEditable(self) -> bool
| C++: virtual bool GetEditable()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Get MTime which also considers its vtkPoints MTime.
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| See vtkDataSet for additional information.
|
| GetPoint(...)
| GetPoint(self, ptId:int, x:[float, float, float]) -> None
| C++: void GetPoint(vtkIdType ptId, double x[3]) override;
| GetPoint(self, ptId:int) -> (float, float, float)
| C++: double *GetPoint(vtkIdType ptId) override;
|
| Copy point coordinates into user provided array x[3] for
| specified point id. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetPointLocator(...)
| GetPointLocator(self) -> vtkAbstractPointLocator
| C++: virtual vtkAbstractPointLocator *GetPointLocator()
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints() override;
|
| If the subclass has (implicit/explicit) points, then return them.
| Otherwise, create a vtkPoints object and return that.
|
| DO NOT MODIFY THE RETURNED POINTS OBJECT.
|
| SetCellLocator(...)
| SetCellLocator(self, __a:vtkAbstractCellLocator) -> None
| C++: virtual void SetCellLocator(vtkAbstractCellLocator *)
|
| Set / get an instance of vtkAbstractCellLocator which may be used
| when a vtkCellLocatorStrategy is used during a FindCell()
| operation.
|
| SetEditable(...)
| SetEditable(self, _arg:bool) -> None
| C++: virtual void SetEditable(bool _arg)
|
| Specify whether this dataset is editable after creation. Meaning,
| once the points and cells are defined, can the dataset be
| incrementally modified. By default, this dataset is non-editable
| (i.e., "static") after construction. The reason for this is
| performance: cell links and locators can be built (and destroyed)
| much faster is it is known that the data is static (see
| vtkStaticCellLinks, vtkStaticPointLocator, vtkStaticCellLocator).
|
| SetPointLocator(...)
| SetPointLocator(self, __a:vtkAbstractPointLocator) -> None
| C++: virtual void SetPointLocator(vtkAbstractPointLocator *)
|
| Set / get an instance of vtkAbstractPointLocator which is used to
| support the FindPoint() and FindCell() methods. By default a
| vtkStaticPointLocator is used, unless the class is set as
| Editable, in which case a vtkPointLocator is used.
|
| SetPoints(...)
| SetPoints(self, __a:vtkPoints) -> None
| C++: virtual void SetPoints(vtkPoints *)
|
| Specify point array to define point coordinates.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Overwritten to handle the data/locator loop
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| cell_locator
| read-write, calls GetCellLocator/SetCellLocator
|
| editable
| read-write, calls GetEditable/SetEditable
|
| m_time
| read-only, calls GetMTime
|
| point_locator
| read-write, calls GetPointLocator/SetPointLocator
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| AllocateCellGhostArray(...)
| AllocateCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocateCellGhostArray()
|
| Allocate ghost array for cells.
|
| AllocatePointGhostArray(...)
| AllocatePointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocatePointGhostArray()
|
| Allocate ghost array for points.
|
| CheckAttributes(...)
| CheckAttributes(self) -> int
| C++: int CheckAttributes()
|
| This method checks to see if the cell and point attributes match
| the geometry. Many filters will crash if the number of tuples in
| an array is less than the number of points/cells. This method
| returns 1 if there is a mismatch, and 0 if everything is ok. It
| prints an error if an array is too short, and a warning if an
| array is too long.
|
| CopyAttributes(...)
| CopyAttributes(self, ds:vtkDataSet) -> None
| C++: virtual void CopyAttributes(vtkDataSet *ds)
|
| Copy the attributes associated with the specified dataset to this
| instance of vtkDataSet. THIS METHOD IS NOT THREAD SAFE.
|
| FindAndGetCell(...)
| FindAndGetCell(self, x:[float, float, float], cell:vtkCell,
| cellId:int, tol2:float, subId:int, pcoords:[float, float,
| float], weights:[float, ...]) -> vtkCell
| C++: virtual vtkCell *FindAndGetCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights)
|
| Locate the cell that contains a point and return the cell. Also
| returns the subcell id, parametric coordinates and weights for
| subsequent interpolation. This method combines the derived class
| methods int FindCell and vtkCell *GetCell. Derived classes may
| provide a more efficient implementation. See for example
| vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE.
|
| GenerateGhostArray(...)
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int])
| -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6])
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int],
| cellOnly:bool) -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6],
| bool cellOnly)
|
| Normally called by pipeline executives or algorithms only. This
| method computes the ghost arrays for a given dataset. The zeroExt
| argument specifies the extent of the region which ghost type = 0.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return a pointer to the geometry bounding box in the form
| (xmin,xmax, ymin,ymax, zmin,zmax). THIS METHOD IS NOT THREAD
| SAFE.
|
| GetCellData(...)
| GetCellData(self) -> vtkCellData
| C++: vtkCellData *GetCellData()
|
| Return a pointer to this dataset's cell data. THIS METHOD IS
| THREAD SAFE
|
| GetCellGhostArray(...)
| GetCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellGhostArray()
|
| Get the array that defines the ghost type of each cell. We cache
| the pointer to the array to save a lookup involving string
| comparisons
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: double *GetCenter()
| GetCenter(self, center:[float, float, float]) -> None
| C++: void GetCenter(double center[3])
|
| Get the center of the bounding box. THIS METHOD IS NOT THREAD
| SAFE.
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetGhostArray(int type) override;
|
| Returns the ghost array for the given type (point or cell). Takes
| advantage of the cache with the pointer to the array to save a
| string comparison.
|
| GetLength(...)
| GetLength(self) -> float
| C++: double GetLength()
|
| Return the length of the diagonal of the bounding box. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Return the squared length of the diagonal of the bounding box.
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| GetPointData(...)
| GetPointData(self) -> vtkPointData
| C++: vtkPointData *GetPointData()
|
| Return a pointer to this dataset's point data. THIS METHOD IS
| THREAD SAFE
|
| GetPointGhostArray(...)
| GetPointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetPointGhostArray()
|
| Gets the array that defines the ghost type of each point. We
| cache the pointer to the array to save a lookup involving string
| comparisons
|
| GetScalarRange(...)
| GetScalarRange(self, range:[float, float]) -> None
| C++: virtual void GetScalarRange(double range[2])
| GetScalarRange(self) -> (float, float)
| C++: double *GetScalarRange()
|
| Convenience method to get the range of the first component (and
| only the first component) of any scalars in the data set. If the
| data has both point data and cell data, it returns the (min/max)
| range of combined point and cell data. If there are no point or
| cell scalars the method will return (0,1). Note: It might be
| necessary to call Update to create or refresh the scalars before
| calling this method. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| HasAnyBlankCells(...)
| HasAnyBlankCells(self) -> bool
| C++: virtual bool HasAnyBlankCells()
|
| Returns 1 if there are any blanking cells 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyBlankPoints(...)
| HasAnyBlankPoints(self) -> bool
| C++: virtual bool HasAnyBlankPoints()
|
| Returns 1 if there are any blanking points 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyGhostCells(...)
| HasAnyGhostCells(self) -> bool
| C++: bool HasAnyGhostCells()
|
| Returns 1 if there are any ghost cells 0 otherwise.
|
| HasAnyGhostPoints(...)
| HasAnyGhostPoints(self) -> bool
| C++: bool HasAnyGhostPoints()
|
| Returns 1 if there are any ghost points 0 otherwise.
|
| SetCellOrderAndRationalWeights(...)
| SetCellOrderAndRationalWeights(self, cellId:int,
| cell:vtkGenericCell) -> None
| C++: void SetCellOrderAndRationalWeights(vtkIdType cellId,
| vtkGenericCell *cell)
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| cell_ghost_array
| read-only, calls GetCellGhostArray
|
| length2
| read-only, calls GetLength2
|
| point_ghost_array
| read-only, calls GetPointGhostArray
|
| scalar_range
| read-only, calls GetScalarRange
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| CELL_DATA_FIELD = 2
|
| DATA_OBJECT_FIELD = 0
|
| FieldDataType = <class 'vtkmodules.vtkCommonDataModel.vtkDataSet.Field...
|
| POINT_DATA_FIELD = 1
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: virtual void Crop(const int *updateExtent)
|
| This method crops the data object (if necessary) so that the
| extent matches the update extent.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: virtual int GetExtentType()
|
| The ExtentType will be left as VTK_PIECES_EXTENT for data objects
| such as vtkPolyData and vtkUnstructuredGrid. The ExtentType will
| be changed to VTK_3D_EXTENT for data objects with 3D structure
| such as vtkImageData (and its subclass vtkStructuredPoints),
| vtkRectilinearGrid, and vtkStructuredGrid. The default is the
| have an extent in pieces, with only one piece (no streaming
| possible).
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| extent_type
| read-only, calls GetExtentType
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
pyvista.UnstructuredGridFilters
Python Library Documentation: class UnstructuredGridFilters in module pyvista.core.filters.unstructured_grid
class UnstructuredGridFilters(pyvista.core.filters.data_set.DataSetFilters)
| UnstructuredGridFilters(*args, **kwargs)
|
| An internal class to manage filters/algorithms for unstructured grid datasets.
|
| Method resolution order:
| UnstructuredGridFilters
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| builtins.object
|
| Methods defined here:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| clean(self, tolerance=0, remove_unused_points: 'bool' = True, produce_merge_map: 'bool' = True, average_point_data: 'bool' = True, merging_array_name=None, progress_bar: 'bool' = False)
| Merge duplicate points and remove unused points in an UnstructuredGrid.
|
| This filter, merging coincident points as defined by a merging
| tolerance and optionally removes unused points. The filter does not
| modify the topology of the input dataset, nor change the types of
| cells. It may however, renumber the cell connectivity ids.
|
| This filter implements :vtk:`vtkStaticCleanUnstructuredGrid`.
|
| Parameters
| ----------
| tolerance : float, default: 0.0
| The absolute point merging tolerance.
|
| remove_unused_points : bool, default: True
| Indicate whether points unused by any cell are removed from the
| output. Note that when this is off, the filter can successfully
| process datasets with no cells (and just points). If on in this
| case, and there are no cells, the output will be empty.
|
| produce_merge_map : bool, default: False
| Indicate whether a merge map should be produced on output.
| The merge map, if requested, maps each input point to its
| output point id, or provides a value of -1 if the input point
| is not used in the output. The merge map is associated with
| the filter's output field data and is named ``"PointMergeMap"``.
|
| average_point_data : bool, default: True
| Indicate whether point coordinates and point data of merged points
| are averaged. When ``True``, the data coordinates and attribute
| values of all merged points are averaged. When ``False``, the point
| coordinate and data of the single remaining merged point is
| retained.
|
| merging_array_name : str, optional
| If a ``merging_array_name`` is specified and exists in the
| ``point_data``, then point merging will switch into a mode where
| merged points must be both geometrically coincident and have
| matching point data. When set, ``tolerance`` has no effect.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Cleaned unstructured grid.
|
| See Also
| --------
| remove_unused_points
| Strictly remove unused points `without` merging points.
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Demonstrate cleaning an UnstructuredGrid and show how it can be used to
| average the point data across merged points.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hexbeam = examples.load_hexbeam()
| >>> hexbeam_shifted = hexbeam.translate([1, 0, 0])
| >>> hexbeam.point_data['data'] = [0] * hexbeam.n_points
| >>> hexbeam_shifted.point_data['data'] = [1] * hexbeam.n_points
| >>> merged = hexbeam.merge(hexbeam_shifted, merge_points=False)
| >>> cleaned = merged.clean(average_point_data=True)
| >>> cleaned.n_points < merged.n_points
| True
|
| Show how point averaging using the ``clean`` method with
| ``average_point_data=True`` results in averaged point data for merged
| points.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(merged, scalars='data', show_scalar_bar=False)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cleaned, scalars='data')
| >>> pl.show()
|
| delaunay_2d(self, tol=1e-05, alpha=0.0, offset=1.0, bound: 'bool' = False, inplace: 'bool' = False, edge_source=None, progress_bar: 'bool' = False) from pyvista.core.filters.poly_data.PolyDataFilters
| Apply a 2D Delaunay filter along the best fitting plane.
|
| This filter can be used to generate a 2d surface from a set of
| points on a plane. If you want to create a surface from a
| point cloud, see :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| tol : float, default: 1e-05
| Specify a tolerance to control discarding of closely
| spaced points. This tolerance is specified as a fraction
| of the diagonal length of the bounding box of the points.
|
| alpha : float, default: 0.0
| Specify alpha (or distance) value to control output of
| this filter. For a non-zero alpha value, only edges or
| triangles contained within a sphere centered at mesh
| vertices will be output. Otherwise, only triangles will be
| output.
|
| offset : float, default: 1.0
| Specify a multiplier to control the size of the initial,
| bounding Delaunay triangulation.
|
| bound : bool, default: False
| Boolean controls whether bounding triangulation points
| and associated triangles are included in the
| output. These are introduced as an initial triangulation
| to begin the triangulation process. This feature is nice
| for debugging output.
|
| inplace : bool, default: False
| If ``True``, overwrite this mesh with the triangulated
| mesh.
|
| edge_source : pyvista.PolyData, optional
| Specify the source object used to specify constrained
| edges and loops. If set, and lines/polygons are defined, a
| constrained triangulation is created. The lines/polygons
| are assumed to reference points in the input point set
| (i.e. point ids are identical in the input and
| source).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh from the 2D delaunay filter.
|
| Examples
| --------
| First, generate 30 points on circle and plot them.
|
| >>> import pyvista as pv
| >>> points = pv.Polygon(n_sides=30).points
| >>> circle = pv.PolyData(points)
| >>> circle.plot(show_edges=True, point_size=15)
|
| Use :func:`delaunay_2d` to fill the interior of the circle.
|
| >>> filled_circle = circle.delaunay_2d()
| >>> filled_circle.plot(show_edges=True, line_width=5)
|
| Use the ``edge_source`` parameter to create a constrained delaunay
| triangulation and plot it.
|
| >>> squar = pv.Polygon(n_sides=4, radius=8, fill=False)
| >>> squar = squar.rotate_z(45, inplace=False)
| >>> circ0 = pv.Polygon(center=(2, 3, 0), n_sides=30, radius=1)
| >>> circ1 = pv.Polygon(center=(-2, -3, 0), n_sides=30, radius=1)
| >>> comb = circ0.append_polydata(circ1, squar)
| >>> tess = comb.delaunay_2d(edge_source=comb)
| >>> tess.plot(cpos='xy', show_edges=True)
|
| See :ref:`create_tri_surface_example` for more examples using this filter.
|
| reconstruct_surface(self, nbr_sz=None, sample_spacing=None, progress_bar: 'bool' = False) from pyvista.core.filters.poly_data.PolyDataFilters
| Reconstruct a surface from the points in this dataset.
|
| This filter takes a list of points assumed to lie on the
| surface of a solid 3D object. A signed measure of the distance
| to the surface is computed and sampled on a regular grid. The
| grid can then be contoured at zero to extract the surface. The
| default values for neighborhood size and sample spacing should
| give reasonable results for most uses but can be set if
| desired.
|
| This is helpful when generating surfaces from point clouds and
| is more reliable than :func:`DataSetFilters.delaunay_3d`.
|
| Parameters
| ----------
| nbr_sz : int, optional
| Specify the number of neighbors each point has, used for
| estimating the local surface orientation.
|
| The default value of 20 should be fine for most
| applications, higher values can be specified if the spread
| of points is uneven. Values as low as 10 may yield
| adequate results for some surfaces. Higher values cause
| the algorithm to take longer and will cause
| errors on sharp boundaries.
|
| sample_spacing : float, optional
| The spacing of the 3D sampling grid. If not set, a
| reasonable guess will be made.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Reconstructed surface.
|
| Examples
| --------
| Create a point cloud out of a sphere and reconstruct a surface
| from it.
|
| >>> import pyvista as pv
| >>> points = pv.wrap(pv.Sphere().points)
| >>> surf = points.reconstruct_surface()
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(points)
| >>> _ = pl.add_title('Point Cloud of 3D Surface')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(surf, color=True, show_edges=True)
| >>> _ = pl.add_title('Reconstructed Surface')
| >>> pl.show()
|
| See :ref:`surface_reconstruction_example` for more examples
| using this filter.
|
| remove_unused_points(self: '_UnstructuredGridType', *, inplace: 'bool' = False) -> '_UnstructuredGridType'
| Remove points which are not used by any cells.
|
| Unlike :meth:`clean`, this filter does `not` merge points.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy is returned.
|
| See Also
| --------
| pyvista.PolyDataFilters.remove_unused_points
|
| Returns
| -------
| UnstructuredGrid
| Mesh with unused points removed.
|
| Examples
| --------
| Create :class:`~pyvista.UnstructuredGrid` with three points. The first two points are
| coincident and associated with :attr:`~pyvista.CellType.VERTEX` cells, and the third point
| is "unused" and not associated with any cells.
|
| >>> import pyvista as pv
| >>> cells = [1, 0, 1, 1]
| >>> celltypes = [pv.CellType.VERTEX, pv.CellType.VERTEX]
| >>> points = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]
| >>> grid = pv.UnstructuredGrid(cells, celltypes, points)
| >>> grid
| UnstructuredGrid (...)
| N Cells: 2
| N Points: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 1.000e+00
| N Arrays: 0
|
| Since the third point is unused, we can remove it. Note that coincident points are `not`
| merged by this filter, so the two vertex points are kept as-is.
|
| >>> grid = grid.remove_unused_points()
| >>> grid
| UnstructuredGrid (...)
| N Cells: 2
| N Points: 2
| X Bounds: 0.000e+00, 0.000e+00
| Y Bounds: 0.000e+00, 0.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| N Arrays: 0
|
| subdivide_tetra(self)
| Subdivide each tetrahedron into twelve tetrahedrons.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the subdivided tetrahedrons.
|
| Examples
| --------
| First, load a sample tetrahedral UnstructuredGrid and plot it.
|
| >>> from pyvista import examples
| >>> grid = examples.load_tetbeam()
| >>> grid.plot(show_edges=True, line_width=2)
|
| Now, subdivide and plot.
|
| >>> subdivided = grid.subdivide_tetra()
| >>> subdivided.plot(show_edges=True, line_width=2)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
pyvista.UnstructuredGridWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.VTKDataSetReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.VTKExecutionError
Python Library Documentation: class VTKExecutionError in module pyvista.core.errors class VTKExecutionError(builtins.RuntimeError) | VTKExecutionError(message='VTK output message was detected by PyVista.') -> 'None' | | Exception when a VTK output message is detected. | | .. versionadded:: 0.47 | | Parameters | ---------- | message : str | Error message. | | Method resolution order: | VTKExecutionError | builtins.RuntimeError | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, message='VTK output message was detected by PyVista.') -> 'None' | Call the base class constructor with the custom message. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Static methods inherited from builtins.RuntimeError: | | __new__(*args, **kwargs) class method of builtins.RuntimeError | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.VTKExecutionWarning
Python Library Documentation: class VTKExecutionWarning in module pyvista.core.errors class VTKExecutionWarning(builtins.RuntimeWarning) | Warning when a VTK output message is detected. | | .. versionadded:: 0.47 | | Method resolution order: | VTKExecutionWarning | builtins.RuntimeWarning | builtins.Warning | builtins.Exception | builtins.BaseException | builtins.object | | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Methods inherited from builtins.RuntimeWarning: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.RuntimeWarning: | | __new__(*args, **kwargs) class method of builtins.RuntimeWarning | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.VTKPDataSetReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.VTKVersionError
Python Library Documentation: class VTKVersionError in module pyvista.core.errors class VTKVersionError(builtins.RuntimeError) | VTKVersionError(message='The requested feature is not supported by the installed VTK version.') -> 'None' | | Requested feature is not supported by the installed VTK version. | | Parameters | ---------- | message : str | Error message. | | Method resolution order: | VTKVersionError | builtins.RuntimeError | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, message='The requested feature is not supported by the installed VTK version.') -> 'None' | Empty init. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Static methods inherited from builtins.RuntimeError: | | __new__(*args, **kwargs) class method of builtins.RuntimeError | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pyvista.VectorLike
Python Library Documentation: _UnionGenericAlias in module typing
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
pyvista.VersionInfo
Python Library Documentation: class VersionInfo in module pyvista.core._vtk_utilities
class VersionInfo(builtins.tuple)
| VersionInfo(major: ForwardRef('int'), minor: ForwardRef('int'), micro: ForwardRef('int'))
|
| Version information as a named tuple.
|
| Method resolution order:
| VersionInfo
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.VersionInfo
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.VersionInfo
| Return a nicely formatted representation string
|
| __str__(self)
| Return str(self).
|
| _asdict(self) from collections.VersionInfo
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.VersionInfo
| Return a new VersionInfo object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.VersionInfo
| Make a new VersionInfo object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, major: ForwardRef('int'), minor: ForwardRef('int'), micro: ForwardRef('int')) from namedtuple_VersionInfo.VersionInfo
| Create new instance of VersionInfo(major, minor, micro)
|
| _format(version: 'tuple[int, int, int]')
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| major
| Alias for field number 0
|
| minor
| Alias for field number 1
|
| micro
| Alias for field number 2
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'major': ForwardRef('int'), 'micro': ForwardRef('in...
|
| __match_args__ = ('major', 'minor', 'micro')
|
| __orig_bases__ = (<function NamedTuple>,)
|
| _field_defaults = {}
|
| _fields = ('major', 'minor', 'micro')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
pyvista.VtkErrorCatcher
Python Library Documentation: class VtkErrorCatcher in module pyvista.core.utilities.observers class VtkErrorCatcher(builtins.object) | VtkErrorCatcher(raise_errors: 'bool' = False, send_to_logging: 'bool' = True, emit_warnings: 'bool' = False) -> 'None' | | Context manager to temporarily catch VTK errors. | | Parameters | ---------- | raise_errors : bool, default: False | Raise a ``pyvista.VTKExecutionError`` (a runtime error) when a VTK error | is observed. | | .. versionchanged:: 0.47 | | A ``pyvista.VTKExecutionError`` is now raised instead of a generic | ``RuntimeError``. | | send_to_logging : bool, default: True | Determine whether VTK errors raised within the context should | also be sent to logging. | | emit_warnings : bool, default: False | Emit a ``pyvista.VTKExecutionWarning`` (a runtime warning) when a VTK warning | is observed. | | .. versionadded:: 0.47 | | Examples | -------- | Catch VTK errors using the context manager. This only sends to | logging by default. | | >>> import pyvista as pv | >>> with pv.VtkErrorCatcher() as error_catcher: | ... sphere = pv.Sphere() | | Raise VTK errors as Python errors and emit VTK warnings as Python warnings. | | >>> with pv.VtkErrorCatcher( | ... raise_errors=True, emit_warnings=True | ... ) as error_catcher: | ... sphere = pv.Sphere() | | Methods defined here: | | __enter__(self: 'Self') -> 'Self' | Observe VTK string output window for errors. | | __exit__(self, *args) | Stop observing VTK string output window. | | __init__(self, raise_errors: 'bool' = False, send_to_logging: 'bool' = True, emit_warnings: 'bool' = False) -> 'None' | Initialize context manager. | | ---------------------------------------------------------------------- | Readonly properties defined here: | | error_events | List of VTK error events observed. | | .. versionadded:: 0.47 | | events | List of all VTK warning and error events observed. | | .. versionadded:: 0.47 | | warning_events | List of VTK error events observed. | | .. versionadded:: 0.47 | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object
pyvista.Wavelet
Python Library Documentation: function Wavelet in module pyvista.core.utilities.geometric_objects
Wavelet(extent: 'VectorLike[float]' = (-10, 10, -10, 10, -10, 10), center: 'VectorLike[float]' = (0.0, 0.0, 0.0), maximum: 'float' = 255.0, x_freq: 'float' = 60.0, y_freq: 'float' = 30.0, z_freq: 'float' = 40.0, x_mag: 'float' = 10.0, y_mag: 'float' = 18.0, z_mag: 'float' = 5.0, std: 'float' = 0.5, subsample_rate: 'int' = 1) -> 'ImageData'
Create a wavelet.
Produces images with pixel values determined by
``Maximum*Gaussian*x_mag*sin(x_freq*x)*sin(y_freq*y)*cos(z_freq*z)``
Values are float scalars on point data with name ``"RTData"``.
Parameters
----------
extent : sequence[int], default: (-10, 10, -10, 10, -10, 10)
Set/Get the extent of the whole output image.
center : sequence[float], default: (0.0, 0.0, 0.0)
Center of the wavelet.
maximum : float, default: 255.0
Maximum of the wavelet function.
x_freq : float, default: 60.0
Natural frequency in the x direction.
y_freq : float, default: 30.0
Natural frequency in the y direction.
z_freq : float, default: 40.0
Natural frequency in the z direction.
x_mag : float, default: 10.0
Magnitude in the x direction.
y_mag : float, default: 18.0
Magnitude in the y direction.
z_mag : float, default: 5.0
Magnitude in the z direction.
std : float, default: 0.5
Standard deviation.
subsample_rate : int, default: 1
The sub-sample rate.
Returns
-------
pyvista.ImageData
Wavelet mesh.
Examples
--------
>>> import pyvista as pv
>>> wavelet = pv.Wavelet(
... extent=(0, 50, 0, 50, 0, 10),
... x_freq=20,
... y_freq=10,
... z_freq=1,
... x_mag=100,
... y_mag=100,
... z_mag=1000,
... )
>>> wavelet.plot(show_scalar_bar=False)
Extract lower valued cells of the wavelet and create a surface from it.
>>> thresh = wavelet.threshold(800).extract_surface(algorithm=None)
>>> thresh.plot(show_scalar_bar=False)
Smooth it to create "waves"
>>> waves = thresh.smooth(n_iter=100, relaxation_factor=0.1)
>>> waves.plot(color='white', smooth_shading=True, show_edges=True)
pyvista.WriterRegistration
Python Library Documentation: class WriterRegistration in module pyvista.core.utilities.writer_registry
class WriterRegistration(builtins.tuple)
| WriterRegistration(extension: ForwardRef('str'), handler: ForwardRef('WriterHandler'), source: ForwardRef('str'))
|
| Describe one registered custom writer.
|
| Returned by :func:`~pyvista.registered_writers`.
|
| .. versionadded:: 0.48.0
|
| Attributes
| ----------
| extension : str
| File extension the writer is registered against, including the
| leading dot (e.g. ``'.myformat'``).
| handler : callable
| The writer callable.
| source : str
| Human-readable origin in the form ``'module.qualname'`` for
| explicit registrations or the entry-point ``value`` for
| plugin-discovered registrations.
|
| Method resolution order:
| WriterRegistration
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.WriterRegistration
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.WriterRegistration
| Return a nicely formatted representation string
|
| _asdict(self) from collections.WriterRegistration
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.WriterRegistration
| Return a new WriterRegistration object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.WriterRegistration
| Make a new WriterRegistration object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, extension: ForwardRef('str'), handler: ForwardRef('WriterHandler'), source: ForwardRef('str')) from namedtuple_WriterRegistration.WriterRegistration
| Create new instance of WriterRegistration(extension, handler, source)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| extension
| Alias for field number 0
|
| handler
| Alias for field number 1
|
| source
| Alias for field number 2
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'extension': ForwardRef('str'), 'handler': ForwardR...
|
| __match_args__ = ('extension', 'handler', 'source')
|
| __orig_bases__ = (<function NamedTuple>,)
|
| _field_defaults = {}
|
| _fields = ('extension', 'handler', 'source')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
pyvista.XMLImageDataReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLImageDataWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLMultiBlockDataReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLMultiBlockDataWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLPImageDataReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLPRectilinearGridReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLPUnstructuredGridReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLPartitionedDataSetReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLPartitionedDataSetWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLPolyDataReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLPolyDataWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLRectilinearGridReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLRectilinearGridWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLStructuredGridReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLStructuredGridWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLUnstructuredGridReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.XMLUnstructuredGridWriter
Error rendering doc: 'NoneType' object is not iterable
pyvista.XdmfReader
Error rendering doc: 'NoneType' object is not iterable
pyvista.abstract_class
Python Library Documentation: function abstract_class in module pyvista.core.utilities.misc
abstract_class(cls_)
Decorate a class, overriding __new__.
Preventing a class from being instantiated similar to abc.ABCMeta
but does not require an abstract method.
Parameters
----------
cls_ : type
The class to be decorated as abstract.
pyvista.accessor_registry
Python Library Documentation: module pyvista.core.utilities.accessor_registry in pyvista.core.utilities
NAME
pyvista.core.utilities.accessor_registry - Registry for third-party dataset accessors.
DESCRIPTION
This module implements the pandas/xarray-style accessor pattern for PyVista
dataset classes. Plugin packages attach a namespaced accessor to a target
class at import time; the accessor is constructed lazily on first access
per dataset instance and cached on the instance.
Two registration paths are supported:
1. **Explicit import.** A plugin's module runs the
:func:`register_dataset_accessor` decorator at import time, so any
user that does ``import plugin`` gets the accessor attached.
2. **Entry points.** A plugin declares a ``pyvista.accessors`` entry
point in its ``pyproject.toml`` pointing at its accessor module.
PyVista reads the entry-point metadata lazily (no plugin module is
imported at ``import pyvista`` time). The plugin module imports only
when a user first accesses ``dataset.<name>`` on any dataset and the
normal attribute lookup misses. That isolates broken or slow plugins
from the main ``import pyvista`` path.
See Also
--------
pyvista.register_dataset_accessor
pyvista.unregister_dataset_accessor
pyvista.registered_accessors
CLASSES
builtins.tuple(builtins.object)
AccessorRegistration
typing.Protocol(typing.Generic)
DataSetAccessor
class AccessorRegistration(builtins.tuple)
| AccessorRegistration(name: ForwardRef('str'), target: ForwardRef('type'), accessor: ForwardRef('type'), source: ForwardRef('str'))
|
| Describe one registered dataset accessor.
|
| Returned by :func:`~pyvista.registered_accessors`.
|
| .. versionadded:: 0.48.0
|
| Attributes
| ----------
| name : str
| The namespace the accessor is attached under (e.g. ``'meshfix'``).
| target : type
| The PyVista dataset class (or base class) the accessor is
| registered against.
| accessor : type
| The accessor class itself.
| source : str
| Human-readable origin in the form ``'module.qualname'`` — useful
| for debugging which plugin registered a given accessor.
|
| Method resolution order:
| AccessorRegistration
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.AccessorRegistration
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.AccessorRegistration
| Return a nicely formatted representation string
|
| _asdict(self) from collections.AccessorRegistration
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.AccessorRegistration
| Return a new AccessorRegistration object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.AccessorRegistration
| Make a new AccessorRegistration object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, name: ForwardRef('str'), target: ForwardRef('type'), accessor: ForwardRef('type'), source: ForwardRef('str')) from namedtuple_AccessorRegistration.AccessorRegistration
| Create new instance of AccessorRegistration(name, target, accessor, source)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| name
| Alias for field number 0
|
| target
| Alias for field number 1
|
| accessor
| Alias for field number 2
|
| source
| Alias for field number 3
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'accessor': ForwardRef('type'), 'name': ForwardRef(...
|
| __match_args__ = ('name', 'target', 'accessor', 'source')
|
| __orig_bases__ = (<function NamedTuple>,)
|
| _field_defaults = {}
|
| _fields = ('name', 'target', 'accessor', 'source')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class DataSetAccessor(typing.Protocol)
| DataSetAccessor(dataset: 'Any') -> 'None'
|
| Structural protocol for third-party accessor classes.
|
| An accessor class must accept the dataset instance as its single
| ``__init__`` argument. Any public methods on the class become
| available as ``dataset.<namespace>.<method>(...)`` once the class is
| registered with :func:`~pyvista.register_dataset_accessor`.
|
| This Protocol exists primarily for static type analysis: plugin
| authors can annotate ``accessor_cls: type[DataSetAccessor]`` (or
| use it as a return annotation) to have mypy/pyright check that
| their accessor class conforms. The runtime ``isinstance`` check is
| intentionally permissive (every class has ``__init__``), so prefer
| the static-typing use.
|
| .. versionadded:: 0.48.0
|
| Examples
| --------
| Declare an accessor that satisfies the protocol.
|
| >>> from pyvista import DataSetAccessor
| >>> class MyAccessor:
| ... def __init__(self, dataset):
| ... self._dataset = dataset
| >>> isinstance(MyAccessor(None), DataSetAccessor)
| True
|
| Method resolution order:
| DataSetAccessor
| typing.Protocol
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__(self, dataset: 'Any') -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __subclasshook__ = _proto_hook(other) from typing
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| __non_callable_proto_members__ = set()
|
| __parameters__ = ()
|
| __protocol_attrs__ = set()
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Protocol:
|
| __init_subclass__(*args, **kwargs)
| Function to initialize subclasses.
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Generic:
|
| __class_getitem__(...)
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
FUNCTIONS
register_dataset_accessor(name: 'str', target_cls: 'type', *, override: 'bool' = False) -> 'Callable[[type], type]'
Register a custom namespaced accessor on a PyVista dataset class.
Mirrors the accessor pattern used by
`pandas <https://pandas.pydata.org/docs/development/extending.html#registering-custom-accessors>`_
and `xarray <https://docs.xarray.dev/en/stable/internals/extending-xarray.html>`_.
Once registered, the accessor becomes available as
``dataset.<name>.<method>(...)`` on every instance of ``target_cls``
and its subclasses. The accessor class is instantiated lazily on
first access and cached on the dataset instance, so subsequent
accesses return the same accessor object.
.. versionadded:: 0.48.0
Parameters
----------
name : str
The namespace the accessor will be attached under. Must be a
valid Python identifier that does not start with an underscore.
target_cls : type
The PyVista dataset class (or base class) to attach the accessor
to. Registering against :class:`~pyvista.DataSet` exposes the
accessor on every subclass (``PolyData``, ``UnstructuredGrid``,
``ImageData``, and so on). Registering against
:class:`~pyvista.DataObject` additionally covers
:class:`~pyvista.MultiBlock`.
override : bool, default: False
If ``True``, allow registering a name that shadows an existing
built-in attribute on ``target_cls`` (a filter method, property,
or any other non-accessor attribute). The prior attribute is
restored on :func:`~pyvista.unregister_dataset_accessor`.
Returns
-------
callable
Decorator that registers the accessor class passed to it and
returns that class unchanged.
Raises
------
ValueError
If ``name`` is empty, not a valid identifier, starts with ``_``,
or shadows a built-in attribute on ``target_cls`` without
``override=True``.
TypeError
If ``target_cls`` is not a class, or ``name`` is not a string.
Warns
-----
UserWarning
If ``name`` already refers to a registered accessor on
``target_cls`` or any ancestor. Emitting a warning rather than
raising matches pandas' behavior and avoids hard-failing when
two plugins collide.
See Also
--------
pyvista.unregister_dataset_accessor
pyvista.registered_accessors
pyvista.DataSetAccessor
Examples
--------
Register a minimal accessor on :class:`~pyvista.PolyData`.
>>> import pyvista as pv
>>> @pv.register_dataset_accessor('demo', pv.PolyData)
... class DemoAccessor:
... def __init__(self, mesh):
... self._mesh = mesh
...
... def n_points_doubled(self):
... return self._mesh.n_points * 2
>>> sphere = pv.Sphere()
>>> sphere.demo.n_points_doubled() == sphere.n_points * 2
True
The accessor is cached per instance. Repeated access returns the
same object.
>>> sphere.demo is sphere.demo
True
Clean up so the namespace is not visible to later doctest examples.
>>> pv.unregister_dataset_accessor('demo', pv.PolyData)
registered_accessors() -> 'tuple[AccessorRegistration, ...]'
Return every accessor currently registered.
Forces discovery of any pending entry-point plugins so the returned
list reflects every plugin visible to PyVista, not just the ones
that have been touched already via attribute access. A plugin that
fails to import emits a ``UserWarning`` and is skipped; the rest
still appear in the result.
.. versionadded:: 0.48.0
Returns
-------
tuple[AccessorRegistration, ...]
Ordered by registration time. Each record exposes ``name``,
``target``, ``accessor``, and ``source``.
Examples
--------
>>> import pyvista as pv
>>> @pv.register_dataset_accessor('demo_listed', pv.PolyData)
... class DemoListedAccessor:
... def __init__(self, mesh):
... self._mesh = mesh
>>> [r.name for r in pv.registered_accessors() if r.name == 'demo_listed']
['demo_listed']
>>> pv.unregister_dataset_accessor('demo_listed', pv.PolyData)
unregister_dataset_accessor(name: 'str', target_cls: 'type') -> 'None'
Remove an accessor previously attached to a target class.
The inverse of :func:`~pyvista.register_dataset_accessor`. Restores
any built-in attribute that was shadowed via ``override=True`` when
the accessor was registered.
.. versionadded:: 0.48.0
Parameters
----------
name : str
Namespace of the accessor to remove.
target_cls : type
Target class the accessor was registered against. Only accessors
attached directly on ``target_cls`` can be unregistered; an
accessor inherited from a parent class must be unregistered on
that parent.
Raises
------
ValueError
If no accessor named ``name`` is attached directly to
``target_cls``.
TypeError
If ``target_cls`` is not a class, or ``name`` is not a string.
Examples
--------
>>> import pyvista as pv
>>> @pv.register_dataset_accessor('tmp', pv.PolyData)
... class TmpAccessor:
... def __init__(self, mesh):
... self._mesh = mesh
>>> pv.unregister_dataset_accessor('tmp', pv.PolyData)
DATA
ACCESSOR_ENTRY_POINT_GROUP = 'pyvista.accessors'
TYPE_CHECKING = False
__annotations__ = {'_MISSING': 'Any', '_entry_points_loaded': 'bool', ...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\accessor_registry.py
pyvista.allow_new_attributes
Python Library Documentation: _AllowNewAttributes in module pyvista.core.utilities.state_manager object
class _AllowNewAttributes(_StateManager)
| _AllowNewAttributes() -> 'None'
|
| Context manager to control setting new attributes on PyVista classes.
|
| Python allows arbitrarily setting new attributes on objects at any time,
| but PyVista's classes do not always allow this. By default, setting a
| new attribute is only allowed when the attribute's name has a leading
| underscore "``_``", i.e. it is a private attribute; attempting to
| set a new public attribute raises an ``AttributeError``.
|
| This context manager may be used to allow or disallow setting `any` new
| attribute, public or private, either globally or within a context.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| mode : 'private' | bool
| Control if setting new attributes is allowed.
|
| - ``'private'``: Allow setting private attributes, but do not allow setting public
| attributes.
| - ``True``: Allow setting any new attribute, either private or public.
| - ``False``: Do not allow setting new attributes, regardless if they are private or public.
|
| ``'private'`` is used by default, ``True`` removes all restrictions, and ``False``
| is most strict.
|
| .. note::
|
| An attribute is considered private if its name has a leading underscore "``_``".
|
| See Also
| --------
| pyvista.set_new_attribute
| Function for setting any new attribute on a PyVista object.
|
| Notes
| -----
| Allowing new attributes by default outside ``__init__`` and/or without formally defining
| class properties was found to be a source of bugs for both developers and users of PyVista.
| It's very easy to set the wrong attribute name (e.g. ``interpolate`` vs. ``interpolation``)
| without any errors being generated, and users transitioning from older versions of PyVista
| would have code that sets attributes which were once valid, but have since been deprecated and
| removed. Attempting to set an attribute which is not already defined now raises an
| ``AttributeError`` to clearly signal that there is a potential problem with this line of code.
|
| Examples
| --------
| Get the default attribute mode.
|
| >>> import pyvista as pv
| >>> pv.allow_new_attributes()
| 'private'
|
| Setting new `private` attributes on PyVista objects is allowed by default.
|
| >>> mesh = pv.PolyData()
| >>> mesh._foo = 42 # OK
| >>> mesh.foo = 42 # ERROR # doctest: +SKIP
|
| Do not allow setting new attributes.
|
| >>> _ = pv.allow_new_attributes(False)
| >>> mesh._foo = 42 # ERROR # doctest:+SKIP
| >>> mesh.foo = 42 # ERROR # doctest:+SKIP
|
| Note that this state is global and will persist between function calls. Set it
| back to its original state explicitly.
|
| >>> _ = pv.allow_new_attributes('private')
|
| Use it as a context manager instead. This way, the state is only temporarily
| modified and is automatically restored.
|
| >>> with pv.allow_new_attributes(True):
| ... mesh._foo = 42 # OK
| ... mesh.foo = 42 # OK
|
| >>> pv.allow_new_attributes()
| 'private'
|
| Method resolution order:
| _AllowNewAttributes
| _StateManager
| contextlib.AbstractContextManager
| abc.ABC
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| __orig_bases__ = (pyvista.core.utilities.state_manager._StateManager[t...
|
| __parameters__ = ()
|
| ----------------------------------------------------------------------
| Methods inherited from _StateManager:
|
| __call__(self: 'Self', state: 'T | None' = None) -> 'Self | T'
| Call the context manager.
|
| __enter__(self) -> 'None'
| Enter context manager.
|
| __exit__(self, exc_type, exc_value, traceback)
| Exit context manager and restore original state.
|
| __init__(self) -> 'None'
| Initialize context manager.
|
| ----------------------------------------------------------------------
| Class methods inherited from contextlib.AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from contextlib.AbstractContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Generic:
|
| __init_subclass__(...)
| Function to initialize subclasses.
pyvista.annotations
Python Library Documentation: _Feature in module __future__ object class _Feature(builtins.object) | _Feature(optionalRelease, mandatoryRelease, compiler_flag) | | Methods defined here: | | __init__(self, optionalRelease, mandatoryRelease, compiler_flag) | Initialize self. See help(type(self)) for accurate signature. | | __repr__(self) | Return repr(self). | | getMandatoryRelease(self) | Return release in which this feature will become mandatory. | | This is a 5-tuple, of the same form as sys.version_info, or, if | the feature was dropped, or the release date is undetermined, is None. | | getOptionalRelease(self) | Return first release in which this feature was recognized. | | This is a 5-tuple, of the same form as sys.version_info. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object
pyvista.array_from_vtkmatrix
Python Library Documentation: function array_from_vtkmatrix in module pyvista.core.utilities.arrays
array_from_vtkmatrix(matrix: '_vtk.vtkMatrix3x3 | _vtk.vtkMatrix4x4') -> 'NumpyArray[float]'
Convert a vtk matrix to an array.
Parameters
----------
matrix : :vtk:`vtkMatrix3x3` | :vtk:`vtkMatrix4x4`
The vtk matrix to be converted to a ``numpy.ndarray``.
Returned ndarray has shape (3, 3) or (4, 4) as appropriate.
Returns
-------
numpy.ndarray
Numpy array containing the data from ``matrix``.
pyvista.arrays
Python Library Documentation: module pyvista.core.utilities.arrays in pyvista.core.utilities
NAME
pyvista.core.utilities.arrays - Internal array utilities.
CLASSES
enum.Enum(builtins.object)
FieldAssociation
class FieldAssociation(enum.Enum)
| FieldAssociation(*values)
|
| Represents which type of vtk field a scalar or vector array is associated with.
|
| Method resolution order:
| FieldAssociation
| enum.Enum
| builtins.object
|
| Data and other attributes defined here:
|
| CELL = <FieldAssociation.CELL: 1>
|
| NONE = <FieldAssociation.NONE: 2>
|
| POINT = <FieldAssociation.POINT: 0>
|
| ROW = <FieldAssociation.ROW: 6>
|
| ----------------------------------------------------------------------
| Data descriptors inherited from enum.Enum:
|
| name
| The name of the Enum member.
|
| value
| The value of the Enum member.
|
| ----------------------------------------------------------------------
| Static methods inherited from enum.EnumType:
|
| __contains__(value)
| Return True if `value` is in `cls`.
|
| `value` is in `cls` if:
| 1) `value` is a member of `cls`, or
| 2) `value` is the value of one of the `cls`'s members.
|
| __getitem__(name)
| Return the member matching `name`.
|
| __iter__()
| Return members in definition order.
|
| __len__()
| Return the number of members (no aliases)
|
| ----------------------------------------------------------------------
| Readonly properties inherited from enum.EnumType:
|
| __members__
| Returns a mapping of member name->value.
|
| This mapping lists all enum members, including aliases. Note that this
| is a read-only view of the internal mapping.
FUNCTIONS
array_from_vtkmatrix(matrix: '_vtk.vtkMatrix3x3 | _vtk.vtkMatrix4x4') -> 'NumpyArray[float]'
Convert a vtk matrix to an array.
Parameters
----------
matrix : :vtk:`vtkMatrix3x3` | :vtk:`vtkMatrix4x4`
The vtk matrix to be converted to a ``numpy.ndarray``.
Returned ndarray has shape (3, 3) or (4, 4) as appropriate.
Returns
-------
numpy.ndarray
Numpy array containing the data from ``matrix``.
cell_array(obj: 'DataSet | _vtk.vtkDataSet', name: 'str') -> 'pyvista_ndarray | None'
Return cell array of a pyvista or vtk object.
Parameters
----------
obj : DataSet | :vtk:`vtkDataSet`
PyVista or VTK dataset.
name : str | int
Name or index of the array.
Returns
-------
output : pyvista.pyvista_ndarray | None
Wrapped array if the index or name is valid. Otherwise, ``None``.
convert_array(arr: 'npt.ArrayLike | _vtk.vtkAbstractArray | None', name: 'str | None' = None, deep: 'bool' = False, array_type: 'int | None' = None) -> 'npt.NDArray[Any] | _vtk.vtkAbstractArray | None'
Convert a NumPy array to a :vtk:`vtkDataArray` or vice versa.
Parameters
----------
arr : np.ndarray | :vtk:`vtkDataArray`
A numpy array or :vtk:`vtkDataArray` to convert.
name : str, optional
The name of the data array for VTK.
deep : bool, default: False
If input is numpy array then deep copy values.
array_type : int, optional
VTK array type ID as specified in ``vtkType.h``.
Returns
-------
output : :vtk:`vtkDataArray` | numpy.ndarray
The converted array. If input is a :class:`numpy.ndarray` then
returns :vtk:`vtkDataArray` or if input is :vtk:`vtkDataArray` then
returns NumPy ``ndarray``.
convert_string_array(arr: 'str | npt.NDArray[np.str_] | _vtk.vtkStringArray', name: 'str | None' = None) -> 'npt.NDArray[np.str_] | _vtk.vtkStringArray'
Convert a numpy array of strings to a :vtk:`vtkStringArray` or vice versa.
If a scalar string is provided, it is converted to a :vtk:`vtkCharArray`
Parameters
----------
arr : numpy.ndarray | str
Numpy string array to convert.
name : str, optional
Name to set the :vtk:`vtkStringArray` to.
Returns
-------
:vtk:`vtkStringArray`
VTK string array.
Notes
-----
Note that this is terribly inefficient. If you have ideas on how
to make this faster, please consider opening a pull request.
copy_vtk_array(array: '_vtk.vtkAbstractArray', deep: 'bool' = True) -> '_vtk.vtkAbstractArray'
Create a deep or shallow copy of a VTK array.
Parameters
----------
array : :vtk:`vtkAbstractArray`
VTK array.
deep : bool, optional
When ``True``, create a deep copy of the array. When ``False``, returns
a shallow copy.
Returns
-------
:vtk:`vtkAbstractArray`
Copy of the original VTK array.
Examples
--------
Perform a deep copy of a vtk array.
>>> import vtk
>>> import pyvista as pv
>>> arr = vtk.vtkFloatArray()
>>> _ = arr.SetNumberOfValues(10)
>>> arr.SetValue(0, 1)
>>> arr_copy = pv.core.utilities.arrays.copy_vtk_array(arr)
>>> arr_copy.GetValue(0)
1.0
field_array(obj: 'DataSet | _vtk.vtkDataSet', name: 'str') -> 'pyvista_ndarray | None'
Return field data of a pyvista or vtk object.
Parameters
----------
obj : DataSet | :vtk:`vtkDataSet`
PyVista or VTK dataset.
name : str | int
Name or index of the array.
Returns
-------
output : pyvista.pyvista_ndarray | None
Wrapped array if the index or name is valid. Otherwise, ``None``.
get_array(mesh: 'DataSet | _vtk.vtkDataSet | _vtk.vtkTable', name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral | RowLiteral' = 'cell', err: 'bool' = False) -> 'pyvista_ndarray | None'
Search point, cell and field data for an array.
Parameters
----------
mesh : pyvista.DataSet
Dataset to get the array from.
name : str
The name of the array to get the range.
preference : str, default: "cell"
When scalars is specified, this is the preferred array type to
search for in the dataset. Must be either ``'point'``,
``'cell'``, or ``'field'``.
err : bool, default: False
Whether to throw an error if array is not present.
Returns
-------
output : pyvista.pyvista_ndarray | None
Requested array. Return ``None`` if there is no array
matching the ``name`` and ``err=False``.
get_array_association(mesh: 'DataSet | _vtk.vtkDataSet | _vtk.vtkTable', name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral | RowLiteral' = 'cell', err: 'bool' = False) -> 'FieldAssociation'
Return the array association.
Parameters
----------
mesh : pyvista.DataSet
Dataset to get the array association from.
name : str
The name of the array.
preference : str, default: "cell"
When scalars is specified, this is the preferred array type to
search for in the dataset. Must be either ``'point'``,
``'cell'``, or ``'field'``.
err : bool, default: False
Boolean to control whether to throw an error if array is not
present.
Returns
-------
pyvista.core.utilities.arrays.FieldAssociation
Association of the array. If array is not present and ``err`` is
``False``, ``FieldAssociation.NONE`` is returned.
get_vtk_type(typ: 'npt.DTypeLike') -> 'int'
Look up the VTK type for a given numpy data type.
Corrects for string type mapping issues.
Parameters
----------
typ : numpy.dtype
Numpy data type.
Returns
-------
int
Integer type id specified in ``vtkType.h``.
has_duplicates(arr: 'NumpyArray[Any]') -> 'bool'
Return if an array has any duplicates.
Parameters
----------
arr : numpy.ndarray
Array to be checked for duplicates.
Returns
-------
bool
``True`` if the array has any duplicates, otherwise ``False``.
parse_field_choice(field: "FieldAssociation | PointLiteral | CellLiteral | FieldLiteral | RowLiteral | Literal['p', 'c', 'f', 'r', 'points', 'cells', 'fields']") -> 'FieldAssociation'
Return a field association object for a given field type string.
Parameters
----------
field : str, FieldAssociation
Name of the field (e.g, ``'cell'``, ``'field'``, ``'point'``,
``'row'``).
Returns
-------
pyvista.FieldAssociation
Field association.
point_array(obj: 'DataSet | _vtk.vtkDataSet', name: 'str') -> 'pyvista_ndarray | None'
Return point array of a pyvista or vtk object.
Parameters
----------
obj : DataSet | :vtk:`vtkDataSet`
PyVista or VTK dataset.
name : str | int
Name or index of the array.
Returns
-------
output : pyvista.pyvista_ndarray | None
Wrapped array if the index or name is valid. Otherwise, ``None``.
raise_has_duplicates(arr: 'NumpyArray[Any]') -> 'None'
Raise a ValueError if an array is not unique.
Parameters
----------
arr : numpy.ndarray
Array to be checked for duplicates.
Raises
------
ValueError
If the array contains duplicate values.
raise_not_matching(scalars: 'npt.NDArray[Any]', dataset: 'DataSet | Table') -> 'None'
Raise exception about inconsistencies.
Parameters
----------
scalars : numpy.ndarray
Array of scalars.
dataset : pyvista.DataSet | pyvista.Table
Dataset to check against.
Raises
------
ValueError
Raises a ValueError if the size of scalars does not the dataset.
row_array(obj: '_vtk.vtkTable', name: 'str') -> 'pyvista_ndarray | None'
Return row array of a vtk object.
Parameters
----------
obj : :vtk:`vtkTable`
PyVista or VTK table.
name : str
Name of the array.
Returns
-------
numpy.ndarray
Wrapped array.
set_default_active_scalars(mesh: 'DataSet') -> '_ActiveArrayExistsInfoTuple'
Set a default scalars array on mesh, if not already set.
If an active scalars already exists, no changes are made.
If an active scalars does not exist, it checks for point or cell
arrays. If only one exists, then it is set as the active scalars.
Otherwise, an error is raised.
.. versionchanged:: 0.45
The field and name of the active array is now returned.
Previously, ``None`` was returned.
Parameters
----------
mesh : pyvista.DataSet
Dataset to set default active scalars.
Raises
------
pyvista.core.errors.MissingDataError
If no arrays exist.
pyvista.core.errors.AmbiguousDataError
If more than one array exists.
Returns
-------
tuple[FieldAssociation, str]
The field and name of the active array.
set_default_active_vectors(mesh: 'DataSet') -> '_ActiveArrayExistsInfoTuple'
Set a default vectors array on mesh, if not already set.
If an active vector already exists, no changes are made.
If an active vectors does not exist, it checks for possibly cell
or point arrays with shape ``(n, 3)``. If only one exists, then
it is set as the active vectors. Otherwise, an error is raised.
.. versionchanged:: 0.45
The field and name of the active array is now returned.
Previously, ``None`` was returned.
Parameters
----------
mesh : pyvista.DataSet
Dataset to set default active vectors.
Raises
------
pyvista.core.errors.MissingDataError
If no vector-like arrays exist.
pyvista.core.errors.AmbiguousDataError
If more than one vector-like arrays exist.
Returns
-------
tuple[FieldAssociation, str]
The field and name of the active array.
vtk_bit_array_to_char(vtkarr_bint: '_vtk.vtkBitArray') -> '_vtk.vtkCharArray'
Cast vtk bit array to a char array.
Parameters
----------
vtkarr_bint : :vtk:`vtkBitArray`
VTK binary array.
Returns
-------
:vtk:`vtkCharArray`
VTK char array.
Notes
-----
This performs a copy.
vtk_id_list_to_array(vtk_id_list: '_vtk.vtkIdList') -> 'NumpyArray[int]'
Convert a :vtk:`vtkIdList` to a NumPy array.
Parameters
----------
vtk_id_list : :vtk:`vtkIdList`
VTK ID list.
Returns
-------
numpy.ndarray
Array of IDs.
vtkmatrix_from_array(array: 'NumpyArray[float]') -> '_vtk.vtkMatrix3x3 | _vtk.vtkMatrix4x4'
Convert a ``numpy.ndarray`` or array-like to a vtk matrix.
Parameters
----------
array : array_like[float]
The array or array-like to be converted to a vtk matrix.
Shape (3, 3) gets converted to a :vtk:`vtkMatrix3x3`, shape (4, 4)
gets converted to a :vtk:`vtkMatrix4x4`. No other shapes are valid.
Returns
-------
output : :vtk:`vtkMatrix3x3` | :vtk:`vtkMatrix4x4`
VTK matrix.
DATA
CellLiteral = typing.Literal[<FieldAssociation.CELL: 1>, 'cell']
FieldLiteral = typing.Literal[<FieldAssociation.NONE: 2>, 'field']
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
PointLiteral = typing.Literal[<FieldAssociation.POINT: 0>, 'point']
RowLiteral = typing.Literal[<FieldAssociation.ROW: 6>, 'row']
TYPE_CHECKING = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\arrays.py
pyvista.assert_empty_kwargs
Python Library Documentation: function assert_empty_kwargs in module pyvista.core.utilities.misc
assert_empty_kwargs(**kwargs) -> 'bool'
Assert that all keyword arguments have been used (internal helper).
If any keyword arguments are passed, a ``TypeError`` is raised.
Parameters
----------
**kwargs : dict
Keyword arguments passed to the function.
Returns
-------
bool
``True`` when successful.
Raises
------
TypeError
If any keyword arguments are passed, a ``TypeError`` is raised.
pyvista.axis_rotation
Python Library Documentation: function axis_rotation in module pyvista.core.utilities.helpers
axis_rotation(points: 'NumpyArray[float]', angle: 'float', inplace: 'bool' = False, deg: 'bool' = True, axis='z')
Rotate points by angle about an axis.
Parameters
----------
points : numpy.ndarray
Array of points with shape ``(N, 3)``.
angle : float
Rotation angle.
inplace : bool, default: False
Updates points in-place while returning nothing.
deg : bool, default: True
If ``True``, the angle is interpreted as degrees instead of
radians.
axis : str, default: "z"
Name of axis to rotate about. Valid options are ``'x'``, ``'y'``,
and ``'z'``.
Returns
-------
numpy.ndarray
Rotated points.
Examples
--------
Rotate a set of points by 90 degrees about the x-axis in-place.
>>> import numpy as np
>>> import pyvista as pv
>>> from pyvista import examples
>>> points = examples.load_airplane().points
>>> points_orig = points.copy()
>>> pv.axis_rotation(points, 90, axis='x', deg=True, inplace=True)
>>> assert np.all(np.isclose(points[:, 0], points_orig[:, 0]))
>>> assert np.all(np.isclose(points[:, 1], -points_orig[:, 2]))
>>> assert np.all(np.isclose(points[:, 2], points_orig[:, 1]))
pyvista.cartesian_to_spherical
Python Library Documentation: function cartesian_to_spherical in module pyvista.core.utilities.features
cartesian_to_spherical(x, y, z)
Convert 3D Cartesian coordinates to spherical coordinates.
Parameters
----------
x, y, z : numpy.ndarray
Cartesian coordinates.
Returns
-------
r : numpy.ndarray
Radial distance.
phi : numpy.ndarray
Angle (radians) with respect to the polar axis. Also known
as polar angle.
theta : numpy.ndarray
Angle (radians) of rotation from the initial meridian plane.
Also known as azimuthal angle.
Examples
--------
>>> import numpy as np
>>> import pyvista as pv
>>> grid = pv.ImageData(dimensions=(3, 3, 3))
>>> x, y, z = grid.points.T
>>> r, phi, theta = pv.cartesian_to_spherical(x, y, z)
pyvista.cell
Python Library Documentation: module pyvista.core.cell in pyvista.core
NAME
pyvista.core.cell - Contains the pyvista.Cell class.
CLASSES
pyvista.core._vtk_utilities.DisableVtkSnakeCase(builtins.object)
CellArray(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride, vtkmodules.vtkCommonDataModel.vtkCellArray)
pyvista.core._vtk_utilities.vtkPyVistaOverride(builtins.object)
CellArray(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride, vtkmodules.vtkCommonDataModel.vtkCellArray)
pyvista.core.dataobject.DataObject(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride)
Cell(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.dataobject.DataObject, vtkmodules.vtkCommonDataModel.vtkGenericCell)
pyvista.core.utilities.misc._BoundsSizeMixin(builtins.object)
Cell(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.dataobject.DataObject, vtkmodules.vtkCommonDataModel.vtkGenericCell)
pyvista.core.utilities.misc._NoNewAttrMixin(builtins.object)
CellArray(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride, vtkmodules.vtkCommonDataModel.vtkCellArray)
vtkmodules.vtkCommonDataModel.vtkCellArray(vtkmodules.vtkCommonDataModel.vtkAbstractCellArray)
CellArray(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride, vtkmodules.vtkCommonDataModel.vtkCellArray)
vtkmodules.vtkCommonDataModel.vtkGenericCell(vtkmodules.vtkCommonDataModel.vtkCell)
Cell(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.dataobject.DataObject, vtkmodules.vtkCommonDataModel.vtkGenericCell)
class Cell(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.dataobject.DataObject, vtkmodules.vtkCommonDataModel.vtkGenericCell)
| Cell(*args, **kwargs) -> '_T'
|
| Wrapping of :vtk:`vtkCell`.
|
| This class provides the capability to access a given cell topology and can
| be useful when walking through a cell's individual faces or investigating
| cell properties.
|
| Parameters
| ----------
| vtk_cell : :vtk:`vtkCell`, optional
| The vtk object to wrap as Cell, that must be of :vtk:`vtkCell` type.
|
| cell_type : int, optional
| VTK cell type. Determined from ``vtk_cell`` if not input.
|
| deep : bool, default: False
| Perform a deep copy of the original cell.
|
| See Also
| --------
| pyvista.CellType
|
| Notes
| -----
| Accessing individual cells from a :class:`pyvista.DataSet` using this class
| will be much slower than accessing bulk data from the
| :attr:`pyvista.PolyData.faces` or :attr:`pyvista.UnstructuredGrid.cells` attributes.
|
| Also note that the cell object is a deep copy of the original cell and
| is unassociated with the original cell. Changing any data of
| that cell (for example, :attr:`pyvista.Cell.points`) will not change the original dataset.
|
| Examples
| --------
| Get the 0-th cell from a :class:`pyvista.PolyData`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> cell = mesh.get_cell(0)
| >>> cell # doctest: +SKIP
| Cell (0x7fa760075a10)
| Type: <CellType.TRIANGLE: 5>
| Linear: True
| Dimension: 2
| N Points: 3
| N Faces: 0
| N Edges: 3
| X Bounds: -5.406e-02, -5.551e-17
| Y Bounds: 0.000e+00, 1.124e-02
| Z Bounds: -5.000e-01, -4.971e-01
|
| Get the 0-th cell from a :class:`pyvista.UnstructuredGrid`.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> cell = mesh.get_cell(0)
| >>> cell # doctest: +SKIP
| Cell (0x7fdc71a3c210)
| Type: <CellType.HEXAHEDRON: 12>
| Linear: True
| Dimension: 3
| N Points: 8
| N Faces: 6
| N Edges: 12
| X Bounds: 0.000e+00, 5.000e-01
| Y Bounds: 0.000e+00, 5.000e-01
| Z Bounds: 0.000e+00, 5.000e-01
|
| Method resolution order:
| Cell
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkGenericCell
| vtkmodules.vtkCommonDataModel.vtkCell
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'Self', vtk_cell: '_vtk.vtkCell | None' = None, cell_type: 'CellType | None' = None, deep: 'bool' = False) -> 'None'
| Initialize the cell.
|
| __repr__(self: 'Self') -> 'str'
| Return the object representation.
|
| __str__(self: 'Self') -> 'str'
| Return the object string representation.
|
| cast_to_polydata(self: 'Self') -> 'PolyData'
| Cast this cell to PolyData.
|
| Can only be used for 0D, 1D, or 2D cells.
|
| Returns
| -------
| pyvista.PolyData
| This cell cast to a :class:`pyvista.PolyData`.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_sphere()
| >>> cell = mesh.get_cell(0)
| >>> grid = cell.cast_to_polydata()
| >>> grid # doctest: +SKIP
| PolyData (0x7f09ae437b80)
| N Cells: 1
| N Points: 3
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+01
| Y Bounds: 0.000e+00, 2.500e+01
| Z Bounds: -1.270e+02, -1.250e+02
| N Arrays: 0
|
| cast_to_unstructured_grid(self: 'Self') -> 'UnstructuredGrid'
| Cast this cell to an unstructured grid.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| This cell cast to a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> cell = mesh.get_cell(0)
| >>> grid = cell.cast_to_unstructured_grid()
| >>> grid # doctest: +SKIP
| UnstructuredGrid (0x7f9383619540)
| N Cells: 1
| N Points: 8
| X Bounds: 0.000e+00, 5.000e-01
| Y Bounds: 0.000e+00, 5.000e-01
| Z Bounds: 0.000e+00, 5.000e-01
| N Arrays: 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the cell.
|
| Parameters
| ----------
| deep : bool, optional
| When ``True`` makes a full copy of the cell. When ``False``,
| performs a shallow copy where the new cell still references the
| original cell.
|
| Returns
| -------
| pyvista.Cell
| Deep or shallow copy of the cell.
|
| Examples
| --------
| Create a deep copy of the cell and demonstrate it is deep.
|
| >>> from pyvista.examples.cells import Tetrahedron
| >>> mesh = Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> deep_cell = cell.copy(deep=True)
| >>> deep_cell.points[:] = 0
| >>> cell != deep_cell
| True
|
| Create a shallow copy of the cell and demonstrate it is shallow.
|
| >>> shallow_cell = cell.copy(deep=False)
| >>> shallow_cell.points[:] = 0
| >>> cell == shallow_cell
| True
|
| get_edge(self: 'Self', index: 'int') -> 'Cell'
| Get the i-th edge composing the cell.
|
| Parameters
| ----------
| index : int
| Edge ID.
|
| Returns
| -------
| pyvista.Cell
| Edge given by ``index``.
|
| Examples
| --------
| Extract a single edge from a face and output the IDs of the edge
| points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> cell = mesh.get_cell(0)
| >>> edge = cell.get_edge(0)
| >>> edge.point_ids
| [2, 30]
|
| get_face(self: 'Self', index: 'int') -> 'Cell'
| Get the i-th face composing the cell.
|
| Parameters
| ----------
| index : int
| Face ID.
|
| Returns
| -------
| pyvista.Cell
| Face given by ``index``.
|
| Examples
| --------
| Return the face IDs composing the first face of an example tetrahedron.
|
| >>> from pyvista.examples.cells import Tetrahedron
| >>> mesh = Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> face = cell.get_face(0)
| >>> face.point_ids
| [0, 1, 3]
|
| plot(self: 'Self', **kwargs) -> 'None'
| Plot this cell.
|
| Parameters
| ----------
| **kwargs : dict, optional
| See :func:`pyvista.plot` for a description of the optional keyword
| arguments.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> cell = mesh.get_cell(0)
| >>> cell.plot()
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| bounds
| Get the cell bounds in ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| BoundsTuple
| The cell bounds in ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.05405950918793678,
| y_min = 0.0,
| y_max = 0.011239604093134403,
| z_min = 0.49706897139549255,
| z_max = 0.5)
|
| center
| Get the center of the cell.
|
| Uses parametric coordinate center to determine x-y-z center.
|
| Returns
| -------
| tuple[float, float, float]
| The center of the cell.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).center
| (0.03564589594801267, 0.0037465346977114677, 0.49804598093032837)
|
| dimension
| Return the cell dimension.
|
| This returns the dimensionality of the cell. For example, 1 for an edge,
| 2 for a triangle, and 3 for a tetrahedron.
|
| See Also
| --------
| pyvista.CellType.dimension
|
| Returns
| -------
| int
| The cell dimension.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).dimension
| 2
|
| edges
| Return a list of edges composing the cell.
|
| Returns
| -------
| list[Cell]
| A list of edges composing the cell.
|
| Examples
| --------
| >>> from pyvista.examples.cells import Hexahedron
| >>> mesh = Hexahedron()
| >>> cell = mesh.get_cell(0)
| >>> edges = cell.edges
| >>> len(edges)
| 12
|
| faces
| Return a list of faces composing the cell.
|
| Returns
| -------
| list[Cell]
| A list of faces composing the cell.
|
| Examples
| --------
| >>> from pyvista.examples.cells import Tetrahedron
| >>> mesh = Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> faces = cell.faces
| >>> len(faces)
| 4
|
| is_linear
| Return if the cell is linear.
|
| See Also
| --------
| pyvista.CellType.is_linear
|
| Returns
| -------
| bool
| If the cell is linear.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).is_linear
| True
|
| n_edges
| Get the number of edges composing the cell.
|
| See Also
| --------
| pyvista.CellType.n_edges
|
| Returns
| -------
| int
| The number of edges composing the cell.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).n_edges
| 3
|
| n_faces
| Get the number of faces composing the cell.
|
| See Also
| --------
| pyvista.CellType.n_faces
|
| Returns
| -------
| int
| The number of faces.
|
| Examples
| --------
| >>> from pyvista.examples.cells import Tetrahedron
| >>> mesh = Tetrahedron()
| >>> mesh.get_cell(0).n_faces
| 4
|
| n_points
| Get the number of points composing the cell.
|
| See Also
| --------
| pyvista.CellType.n_points
|
| Returns
| -------
| int
| The number of points.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).n_points
| 3
|
| point_ids
| Get the point IDs composing the cell.
|
| Returns
| -------
| list[int]
| The point IDs composing the cell.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).point_ids
| [2, 30, 0]
|
| points
| Get the point coordinates of the cell.
|
| Returns
| -------
| np.ndarray
| The point coordinates of the cell.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).points
| array([[0.05405951, 0. , 0.49706897],
| [0.05287818, 0.0112396 , 0.49706897],
| [0. , 0. , 0.5 ]])
|
| type
| Get the cell type from the enum :class:`pyvista.CellType`.
|
| Returns
| -------
| pyvista.CellType
| Type of cell.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.get_cell(0).type
| <CellType.TRIANGLE: 5>
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'get_data_range', 'is_empty'})
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_meta_from(self: 'Self', *args, **kwargs) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Intended to be overridden by subclasses.
|
| Parameters
| ----------
| *args : tuple
| Positional arguments.
|
| **kwargs : dict, optional
| Keyword arguments.
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| get_data_range(self: 'Self', name: 'str | None', preference: 'FieldAssociation | str') -> 'tuple[float, float]'
| Get the non-NaN min and max of a named array.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| is_empty
| Return ``True`` if the object is empty.
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkGenericCell:
|
| CellBoundary(...)
| CellBoundary(self, subId:int, pcoords:(float, float, float),
| pts:vtkIdList) -> int
| C++: int CellBoundary(int subId, const double pcoords[3],
| vtkIdList *pts) override;
|
| Given parametric coordinates of a point, return the closest cell
| boundary, and whether the point is inside or outside of the cell.
| The cell boundary is defined by a list of points (pts) that
| specify a face (3D cell), edge (2D cell), or vertex (1D cell). If
| the return value of the method is != 0, then the point is inside
| the cell.
|
| Clip(...)
| Clip(self, value:float, cellScalars:vtkDataArray,
| locator:vtkIncrementalPointLocator, connectivity:vtkCellArray,
| inPd:vtkPointData, outPd:vtkPointData, inCd:vtkCellData,
| cellId:int, outCd:vtkCellData, insideOut:int) -> None
| C++: void Clip(double value, vtkDataArray *cellScalars,
| vtkIncrementalPointLocator *locator,
| vtkCellArray *connectivity, vtkPointData *inPd,
| vtkPointData *outPd, vtkCellData *inCd, vtkIdType cellId,
| vtkCellData *outCd, int insideOut) override;
|
| Cut (or clip) the cell based on the input cellScalars and the
| specified value. The output of the clip operation will be one or
| more cells of the same topological dimension as the original
| cell. The flag insideOut controls what part of the cell is
| considered inside - normally cell points whose scalar value is
| greater than "value" are considered inside. If insideOut is on,
| this is reversed. Also, if the output cell data is non-nullptr,
| the cell data from the clipped cell is passed to the generated
| contouring primitives. (Note: the CopyAllocate() method must be
| invoked on both the output cell and point data. The cellId refers
| to the cell from which the cell data is copied.)
|
| Contour(...)
| Contour(self, value:float, cellScalars:vtkDataArray,
| locator:vtkIncrementalPointLocator, verts:vtkCellArray,
| lines:vtkCellArray, polys:vtkCellArray, inPd:vtkPointData,
| outPd:vtkPointData, inCd:vtkCellData, cellId:int,
| outCd:vtkCellData) -> None
| C++: void Contour(double value, vtkDataArray *cellScalars,
| vtkIncrementalPointLocator *locator, vtkCellArray *verts,
| vtkCellArray *lines, vtkCellArray *polys, vtkPointData *inPd,
| vtkPointData *outPd, vtkCellData *inCd, vtkIdType cellId,
| vtkCellData *outCd) override;
|
| Generate contouring primitives. The scalar list cellScalars are
| scalar values at each cell point. The point locator is
| essentially a points list that merges points as they are inserted
| (i.e., prevents duplicates). Contouring primitives can be
| vertices, lines, or polygons. It is possible to interpolate point
| data along the edge by providing input and output point data - if
| outPd is nullptr, then no interpolation is performed. Also, if
| the output cell data is non-nullptr, the cell data from the
| contoured cell is passed to the generated contouring primitives.
| (Note: the CopyAllocate() method must be invoked on both the
| output cell and point data. The cellId refers to the cell from
| which the cell data is copied.)
|
| DeepCopy(...)
| DeepCopy(self, c:vtkCell) -> None
| C++: void DeepCopy(vtkCell *c) override;
|
| Copy this cell by completely copying internal data structures.
| This is slower but safer than ShallowCopy().
|
| Derivatives(...)
| Derivatives(self, subId:int, pcoords:(float, float, float),
| values:(float, ...), dim:int, derivs:[float, ...]) -> None
| C++: void Derivatives(int subId, const double pcoords[3],
| const double *values, int dim, double *derivs) override;
|
| Compute derivatives given cell subId and parametric coordinates.
| The values array is a series of data value(s) at the cell points.
| There is a one-to-one correspondence between cell point and data
| value(s). Dim is the number of data values per cell point. Derivs
| are derivatives in the x-y-z coordinate directions for each data
| value. Thus, if computing derivatives for a scalar function in a
| hexahedron, dim=1, 8 values are supplied, and 3 deriv values are
| returned (i.e., derivatives in x-y-z directions). On the other
| hand, if computing derivatives of velocity (vx,vy,vz) dim=3, 24
| values are supplied ((vx,vy,vz)1, (vx,vy,vz)2, ....()8), and 9
| deriv values are returned ((d(vx)/dx),(d(vx)/dy),(d(vx)/dz),
| (d(vy)/dx),(d(vy)/dy), (d(vy)/dz),
| (d(vz)/dx),(d(vz)/dy),(d(vz)/dz)).
|
| EvaluateLocation(...)
| EvaluateLocation(self, subId:int, pcoords:(float, float, float),
| x:[float, float, float], weights:[float, ...]) -> None
| C++: void EvaluateLocation(int &subId, const double pcoords[3],
| double x[3], double *weights) override;
|
| Determine global coordinate (x[3]) from subId and parametric
| coordinates. Also returns interpolation weights. (The number of
| weights is equal to the number of points in the cell.)
|
| EvaluatePosition(...)
| EvaluatePosition(self, x:(float, float, float),
| closestPoint:[float, float, float], subId:int, pcoords:[float,
| float, float], dist2:float, weights:[float, ...]) -> int
| C++: int EvaluatePosition(const double x[3],
| double closestPoint[3], int &subId, double pcoords[3],
| double &dist2, double weights[]) override;
|
| Given a point x[3] return inside(=1), outside(=0) cell, or (-1)
| computational problem encountered; evaluate parametric
| coordinates, sub-cell id (!=0 only if cell is composite),
| distance squared of point x[3] to cell (in particular, the
| sub-cell indicated), closest point on cell to x[3] (unless
| closestPoint is null, in which case, the closest point and dist2
| are not found), and interpolation weights in cell. (The number of
| weights is equal to the number of points defining the cell).
| Note: on rare occasions a -1 is returned from the method. This
| means that numerical error has occurred and all data returned
| from this method should be ignored. Also, inside/outside is
| determine parametrically. That is, a point is inside if it
| satisfies parametric limits. This can cause problems for cells of
| topological dimension 2 or less, since a point in 3D can project
| onto the cell within parametric limits but be "far" from the
| cell. Thus the value dist2 may be checked to determine true
| in/out.
|
| GetCellDimension(...)
| GetCellDimension(self) -> int
| C++: int GetCellDimension() override;
|
| Return the topological dimensional of the cell (0,1,2, or 3).
|
| GetCellFaces(...)
| GetCellFaces(self) -> vtkCellArray
| C++: vtkCellArray *GetCellFaces()
| GetCellFaces(self, faces:vtkCellArray) -> None
| C++: void GetCellFaces(vtkCellArray *faces)
|
| GetCellType(...)
| GetCellType(self) -> int
| C++: int GetCellType() override;
|
| Return the type of cell.
|
| GetEdge(...)
| GetEdge(self, edgeId:int) -> vtkCell
| C++: vtkCell *GetEdge(int edgeId) override;
|
| Return the edge cell from the edgeId of the cell.
|
| GetFace(...)
| GetFace(self, faceId:int) -> vtkCell
| C++: vtkCell *GetFace(int faceId) override;
|
| Return the face cell from the faceId of the cell. The returned
| vtkCell is an object owned by this instance, hence the return
| value must not be deleted by the caller.
|
| @warning Repeat calls to this function for different face ids
| will change
| the data stored in the internal member object whose pointer is
| returned by this function.
|
| @warning THIS METHOD IS NOT THREAD SAFE.
|
| GetNumberOfEdges(...)
| GetNumberOfEdges(self) -> int
| C++: int GetNumberOfEdges() override;
|
| Return the number of edges in the cell.
|
| GetNumberOfFaces(...)
| GetNumberOfFaces(self) -> int
| C++: int GetNumberOfFaces() override;
|
| Return the number of faces in the cell.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetParametricCenter(...)
| GetParametricCenter(self, pcoords:[float, float, float]) -> int
| C++: int GetParametricCenter(double pcoords[3]) override;
|
| Return center of the cell in parametric coordinates. Note that
| the parametric center is not always located at (0.5,0.5,0.5). The
| return value is the subId that the center is in (if a composite
| cell). If you want the center in x-y-z space, invoke the
| EvaluateLocation() method.
|
| GetParametricCoords(...)
| GetParametricCoords(self) -> (float, ...)
| C++: double *GetParametricCoords() override;
|
| Return a contiguous array of parametric coordinates of the points
| defining this cell. In other words, (px,py,pz, px,py,pz, etc..)
| The coordinates are ordered consistent with the definition of the
| point ordering for the cell. This method returns a non-nullptr
| pointer when the cell is a primary type (i.e., IsPrimaryCell() is
| true). Note that 3D parametric coordinates are returned no matter
| what the topological dimension of the cell.
|
| GetRepresentativeCell(...)
| GetRepresentativeCell(self) -> vtkCell
| C++: vtkCell *GetRepresentativeCell()
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| InstantiateCell(...)
| InstantiateCell(cellType:int) -> vtkCell
| C++: static vtkCell *InstantiateCell(int cellType)
|
| Instantiate a new vtkCell based on it's cell type value
|
| InterpolateDerivs(...)
| InterpolateDerivs(self, pcoords:(float, float, float),
| derivs:[float, ...]) -> None
| C++: void InterpolateDerivs(const double pcoords[3],
| double *derivs) override;
|
| InterpolateFunctions(...)
| InterpolateFunctions(self, pcoords:(float, float, float),
| weights:[float, ...]) -> None
| C++: void InterpolateFunctions(const double pcoords[3],
| double *weights) override;
|
| Compute the interpolation functions/derivatives (aka shape
| functions/derivatives)
|
| IntersectWithLine(...)
| IntersectWithLine(self, p1:(float, float, float), p2:(float,
| float, float), tol:float, t:float, x:[float, float, float],
| pcoords:[float, float, float], subId:int) -> int
| C++: int IntersectWithLine(const double p1[3], const double p2[3],
| double tol, double &t, double x[3], double pcoords[3],
| int &subId) override;
|
| Intersect with a ray. Return parametric coordinates (both line
| and cell) and global intersection coordinates, given ray
| definition p1[3], p2[3] and tolerance tol. The method returns
| non-zero value if intersection occurs. A parametric distance t
| between 0 and 1 along the ray representing the intersection
| point, the point coordinates x[3] in data coordinates and also
| pcoords[3] in parametric coordinates. subId is the index within
| the cell if a composed cell like a triangle strip.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsLinear(...)
| IsLinear(self) -> int
| C++: int IsLinear() override;
|
| Non-linear cells require special treatment beyond the usual cell
| type and connectivity list information. Most cells in VTK are
| implicit cells.
|
| IsPrimaryCell(...)
| IsPrimaryCell(self) -> int
| C++: int IsPrimaryCell() override;
|
| Return whether this cell type has a fixed topology or whether the
| topology varies depending on the data (e.g., vtkConvexPointSet).
| This compares to composite cells that are typically composed of
| primary cells (e.g., a triangle strip composite cell is made up
| of triangle primary cells).
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkGenericCell
| C++: vtkGenericCell *NewInstance()
|
| RequiresExplicitFaceRepresentation(...)
| RequiresExplicitFaceRepresentation(self) -> int
| C++: int RequiresExplicitFaceRepresentation() override;
|
| Determine whether the cell requires explicit face representation,
| and methods for setting and getting the faces (see vtkPolyhedron
| for example usage of these methods).
|
| RequiresInitialization(...)
| RequiresInitialization(self) -> int
| C++: int RequiresInitialization() override;
|
| Some cells require initialization prior to access. For example,
| they may have to triangulate themselves or set up internal data
| structures.
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkGenericCell
| C++: static vtkGenericCell *SafeDownCast(vtkObjectBase *o)
|
| SetCellFaces(...)
| SetCellFaces(self, faces:vtkCellArray) -> int
| C++: int SetCellFaces(vtkCellArray *faces)
|
| SetCellType(...)
| SetCellType(self, cellType:int) -> None
| C++: void SetCellType(int cellType)
|
| This method is used to support the
| vtkDataSet::GetCell(vtkGenericCell *) method. It allows
| vtkGenericCell to act like any cell type by dereferencing an
| internal instance of a concrete cell type. When you set the cell
| type, you are resetting a pointer to an internal cell which is
| then used for computation.
|
| SetCellTypeToBezierCurve(...)
| SetCellTypeToBezierCurve(self) -> None
| C++: void SetCellTypeToBezierCurve()
|
| SetCellTypeToBezierHexahedron(...)
| SetCellTypeToBezierHexahedron(self) -> None
| C++: void SetCellTypeToBezierHexahedron()
|
| SetCellTypeToBezierQuadrilateral(...)
| SetCellTypeToBezierQuadrilateral(self) -> None
| C++: void SetCellTypeToBezierQuadrilateral()
|
| SetCellTypeToBezierTetra(...)
| SetCellTypeToBezierTetra(self) -> None
| C++: void SetCellTypeToBezierTetra()
|
| SetCellTypeToBezierTriangle(...)
| SetCellTypeToBezierTriangle(self) -> None
| C++: void SetCellTypeToBezierTriangle()
|
| SetCellTypeToBezierWedge(...)
| SetCellTypeToBezierWedge(self) -> None
| C++: void SetCellTypeToBezierWedge()
|
| SetCellTypeToBiQuadraticQuad(...)
| SetCellTypeToBiQuadraticQuad(self) -> None
| C++: void SetCellTypeToBiQuadraticQuad()
|
| SetCellTypeToBiQuadraticQuadraticHexahedron(...)
| SetCellTypeToBiQuadraticQuadraticHexahedron(self) -> None
| C++: void SetCellTypeToBiQuadraticQuadraticHexahedron()
|
| SetCellTypeToBiQuadraticQuadraticWedge(...)
| SetCellTypeToBiQuadraticQuadraticWedge(self) -> None
| C++: void SetCellTypeToBiQuadraticQuadraticWedge()
|
| SetCellTypeToBiQuadraticTriangle(...)
| SetCellTypeToBiQuadraticTriangle(self) -> None
| C++: void SetCellTypeToBiQuadraticTriangle()
|
| SetCellTypeToConvexPointSet(...)
| SetCellTypeToConvexPointSet(self) -> None
| C++: void SetCellTypeToConvexPointSet()
|
| SetCellTypeToCubicLine(...)
| SetCellTypeToCubicLine(self) -> None
| C++: void SetCellTypeToCubicLine()
|
| SetCellTypeToEmptyCell(...)
| SetCellTypeToEmptyCell(self) -> None
| C++: void SetCellTypeToEmptyCell()
|
| SetCellTypeToHexagonalPrism(...)
| SetCellTypeToHexagonalPrism(self) -> None
| C++: void SetCellTypeToHexagonalPrism()
|
| SetCellTypeToHexahedron(...)
| SetCellTypeToHexahedron(self) -> None
| C++: void SetCellTypeToHexahedron()
|
| SetCellTypeToLagrangeCurve(...)
| SetCellTypeToLagrangeCurve(self) -> None
| C++: void SetCellTypeToLagrangeCurve()
|
| SetCellTypeToLagrangeHexahedron(...)
| SetCellTypeToLagrangeHexahedron(self) -> None
| C++: void SetCellTypeToLagrangeHexahedron()
|
| SetCellTypeToLagrangeQuadrilateral(...)
| SetCellTypeToLagrangeQuadrilateral(self) -> None
| C++: void SetCellTypeToLagrangeQuadrilateral()
|
| SetCellTypeToLagrangeTetra(...)
| SetCellTypeToLagrangeTetra(self) -> None
| C++: void SetCellTypeToLagrangeTetra()
|
| SetCellTypeToLagrangeTriangle(...)
| SetCellTypeToLagrangeTriangle(self) -> None
| C++: void SetCellTypeToLagrangeTriangle()
|
| SetCellTypeToLagrangeWedge(...)
| SetCellTypeToLagrangeWedge(self) -> None
| C++: void SetCellTypeToLagrangeWedge()
|
| SetCellTypeToLine(...)
| SetCellTypeToLine(self) -> None
| C++: void SetCellTypeToLine()
|
| SetCellTypeToPentagonalPrism(...)
| SetCellTypeToPentagonalPrism(self) -> None
| C++: void SetCellTypeToPentagonalPrism()
|
| SetCellTypeToPixel(...)
| SetCellTypeToPixel(self) -> None
| C++: void SetCellTypeToPixel()
|
| SetCellTypeToPolyLine(...)
| SetCellTypeToPolyLine(self) -> None
| C++: void SetCellTypeToPolyLine()
|
| SetCellTypeToPolyVertex(...)
| SetCellTypeToPolyVertex(self) -> None
| C++: void SetCellTypeToPolyVertex()
|
| SetCellTypeToPolygon(...)
| SetCellTypeToPolygon(self) -> None
| C++: void SetCellTypeToPolygon()
|
| SetCellTypeToPolyhedron(...)
| SetCellTypeToPolyhedron(self) -> None
| C++: void SetCellTypeToPolyhedron()
|
| SetCellTypeToPyramid(...)
| SetCellTypeToPyramid(self) -> None
| C++: void SetCellTypeToPyramid()
|
| SetCellTypeToQuad(...)
| SetCellTypeToQuad(self) -> None
| C++: void SetCellTypeToQuad()
|
| SetCellTypeToQuadraticEdge(...)
| SetCellTypeToQuadraticEdge(self) -> None
| C++: void SetCellTypeToQuadraticEdge()
|
| SetCellTypeToQuadraticHexahedron(...)
| SetCellTypeToQuadraticHexahedron(self) -> None
| C++: void SetCellTypeToQuadraticHexahedron()
|
| SetCellTypeToQuadraticLinearQuad(...)
| SetCellTypeToQuadraticLinearQuad(self) -> None
| C++: void SetCellTypeToQuadraticLinearQuad()
|
| SetCellTypeToQuadraticLinearWedge(...)
| SetCellTypeToQuadraticLinearWedge(self) -> None
| C++: void SetCellTypeToQuadraticLinearWedge()
|
| SetCellTypeToQuadraticPolygon(...)
| SetCellTypeToQuadraticPolygon(self) -> None
| C++: void SetCellTypeToQuadraticPolygon()
|
| SetCellTypeToQuadraticPyramid(...)
| SetCellTypeToQuadraticPyramid(self) -> None
| C++: void SetCellTypeToQuadraticPyramid()
|
| SetCellTypeToQuadraticQuad(...)
| SetCellTypeToQuadraticQuad(self) -> None
| C++: void SetCellTypeToQuadraticQuad()
|
| SetCellTypeToQuadraticTetra(...)
| SetCellTypeToQuadraticTetra(self) -> None
| C++: void SetCellTypeToQuadraticTetra()
|
| SetCellTypeToQuadraticTriangle(...)
| SetCellTypeToQuadraticTriangle(self) -> None
| C++: void SetCellTypeToQuadraticTriangle()
|
| SetCellTypeToQuadraticWedge(...)
| SetCellTypeToQuadraticWedge(self) -> None
| C++: void SetCellTypeToQuadraticWedge()
|
| SetCellTypeToTetra(...)
| SetCellTypeToTetra(self) -> None
| C++: void SetCellTypeToTetra()
|
| SetCellTypeToTriQuadraticHexahedron(...)
| SetCellTypeToTriQuadraticHexahedron(self) -> None
| C++: void SetCellTypeToTriQuadraticHexahedron()
|
| SetCellTypeToTriQuadraticPyramid(...)
| SetCellTypeToTriQuadraticPyramid(self) -> None
| C++: void SetCellTypeToTriQuadraticPyramid()
|
| SetCellTypeToTriangle(...)
| SetCellTypeToTriangle(self) -> None
| C++: void SetCellTypeToTriangle()
|
| SetCellTypeToTriangleStrip(...)
| SetCellTypeToTriangleStrip(self) -> None
| C++: void SetCellTypeToTriangleStrip()
|
| SetCellTypeToVertex(...)
| SetCellTypeToVertex(self) -> None
| C++: void SetCellTypeToVertex()
|
| SetCellTypeToVoxel(...)
| SetCellTypeToVoxel(self) -> None
| C++: void SetCellTypeToVoxel()
|
| SetCellTypeToWedge(...)
| SetCellTypeToWedge(self) -> None
| C++: void SetCellTypeToWedge()
|
| SetPointIds(...)
| SetPointIds(self, pointIds:vtkIdList) -> None
| C++: void SetPointIds(vtkIdList *pointIds)
|
| Set the point ids to use for this cell. This updates the internal
| cell storage as well as the public member variable PointIds.
|
| SetPoints(...)
| SetPoints(self, points:vtkPoints) -> None
| C++: void SetPoints(vtkPoints *points)
|
| Set the points object to use for this cell. This updates the
| internal cell storage as well as the public member variable
| Points.
|
| ShallowCopy(...)
| ShallowCopy(self, c:vtkCell) -> None
| C++: void ShallowCopy(vtkCell *c) override;
|
| See the vtkCell API for descriptions of these methods.
|
| Triangulate(...)
| Triangulate(self, index:int, ptIds:vtkIdList, pts:vtkPoints)
| -> int
| C++: int Triangulate(int index, vtkIdList *ptIds, vtkPoints *pts)
| override;
|
| Generate simplices of proper dimension. If cell is 3D, tetrahedra
| are generated; if 2D triangles; if 1D lines; if 0D points. The
| form of the output is a sequence of points, each n+1 points
| (where n is topological cell dimension) defining a simplex. The
| index is a parameter that controls which triangulation to use (if
| more than one is possible). If numerical degeneracy encountered,
| 0 is returned, otherwise 1 is returned. This method does not
| insert new points: all the points that define the simplices are
| the points that define the cell.
|
| TriangulateIds(...)
| TriangulateIds(self, index:int, ptIds:vtkIdList) -> int
| C++: int TriangulateIds(int index, vtkIdList *ptIds) override;
|
| Generate simplices of proper dimension. If cell is 3D, tetrahedra
| are generated; if 2D triangles; if 1D lines; if 0D points. The
| form of the output is a sequence of points, each n+1 points
| (where n is topological cell dimension) defining a simplex. The
| index is a parameter that controls which triangulation to use (if
| more than one is possible). If numerical degeneracy encountered,
| 0 is returned, otherwise 1 is returned. This method does not
| insert new points: all the points that define the simplices are
| the points that define the cell.
|
| TriangulateLocalIds(...)
| TriangulateLocalIds(self, index:int, ptIds:vtkIdList) -> int
| C++: int TriangulateLocalIds(int index, vtkIdList *ptIds)
| override;
|
| Generate simplices of proper dimension. If cell is 3D, tetrahedra
| are generated; if 2D triangles; if 1D lines; if 0D points. The
| form of the output is a sequence of points, each n+1 points
| (where n is topological cell dimension) defining a simplex. The
| index is a parameter that controls which triangulation to use (if
| more than one is possible). If numerical degeneracy encountered,
| 0 is returned, otherwise 1 is returned. This method does not
| insert new points: all the points that define the simplices are
| the points that define the cell. ptIds are the local indices with
| respect to the cell
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkGenericCell:
|
| __this__
| Pointer to the C++ object.
|
| cell_dimension
| read-only, calls GetCellDimension
|
| cell_faces
| read-only, calls GetCellFaces
|
| cell_type
| read-write, calls GetCellType/SetCellType
|
| number_of_edges
| read-only, calls GetNumberOfEdges
|
| number_of_faces
| read-only, calls GetNumberOfFaces
|
| parametric_coords
| read-only, calls GetParametricCoords
|
| representative_cell
| read-only, calls GetRepresentativeCell
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkGenericCell:
|
| __vtkname__ = 'vtkGenericCell'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkCell:
|
| ComputeBoundingSphere(...)
| ComputeBoundingSphere(self, center:[float, float, float]) -> float
| C++: virtual double ComputeBoundingSphere(double center[3])
|
| Computes the bounding sphere of the cell. If the number of points
| in the cell is lower or equal to 4, an exact bounding sphere is
| computed. If not, Ritter's algorithm is followed. If the input
| sphere has zero points, then each coordinate of center is set to
| NaN, as well as the returned distance.
|
| This method computes the center of the sphere, and returns its
| squared radius.
|
| GetBounds(...)
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
|
| Compute cell bounding box (xmin,xmax,ymin,ymax,zmin,zmax). Copy
| result into user provided array.
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Compute Length squared of cell (i.e., bounding box diagonal
| squared).
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints()
|
| Return the number of points in the cell.
|
| GetParametricDistance(...)
| GetParametricDistance(self, pcoords:(float, float, float))
| -> float
| C++: virtual double GetParametricDistance(const double pcoords[3])
|
| Return the distance of the parametric coordinate provided to the
| cell. If inside the cell, a distance of zero is returned. This is
| used during picking to get the correct cell picked. (The
| tolerance will occasionally allow cells to be picked who are not
| really intersected "inside" the cell.)
|
| GetPointId(...)
| GetPointId(self, ptId:int) -> int
| C++: vtkIdType GetPointId(int ptId)
|
| For cell point i, return the actual point id.
|
| GetPointIds(...)
| GetPointIds(self) -> vtkIdList
| C++: vtkIdList *GetPointIds()
|
| Return the list of point ids defining the cell.
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints()
|
| Get the point coordinates for the cell.
|
| Inflate(...)
| Inflate(self, dist:float) -> int
| C++: virtual int Inflate(double dist)
|
| Inflates the cell. Each edge is displaced following its normal by
| a distance of value `dist`. If dist is negative, then the cell
| shrinks. The resulting cell edges / faces are colinear / coplanar
| to their previous self.
|
| The cell is assumed to be non-degenerate and to have no edge of
| length zero for linear 2D cells. If it is not the case, then no
| inflation is performed. This method needs to be overridden by
| inheriting non-linear / non-2D cells.
|
| \return 1 if inflation was successful, 0 if no inflation was
| performed
|
| IntersectWithCell(...)
| IntersectWithCell(self, other:vtkCell, tol:float=0.0) -> int
| C++: virtual int IntersectWithCell(vtkCell *other, double tol=0.0)
| IntersectWithCell(self, other:vtkCell, boudingBox:vtkBoundingBox,
| otherBoundingBox:vtkBoundingBox, tol:float=0.0) -> int
| C++: virtual int IntersectWithCell(vtkCell *other,
| const vtkBoundingBox &boudingBox,
| const vtkBoundingBox &otherBoundingBox, double tol=0.0)
|
| Intersects with an other cell. Returns 1 if cells intersect, 0
| otherwise. If an exact intersection detection with regards to
| floating point precision is wanted, tol should be disregarded.
| `vtkBoundingBox` are optional parameters which slightly improve
| the speed of the computation if bounding boxes are already
| available to user.
|
| IsExplicitCell(...)
| IsExplicitCell(self) -> int
| C++: virtual int IsExplicitCell()
|
| Explicit cells require additional representational information
| beyond the usual cell type and connectivity list information.
| Most cells in VTK are implicit cells.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkCell:
|
| length2
| read-only, calls GetLength2
|
| number_of_points
| read-only, calls GetNumberOfPoints
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class CellArray(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride, vtkmodules.vtkCommonDataModel.vtkCellArray)
| CellArray(*args, **kwargs) -> '_T'
|
| PyVista wrapping of :vtk:`vtkCellArray`.
|
| Provides convenience functions to simplify creating a CellArray from
| a numpy array or list.
|
| Parameters
| ----------
| cells : np.ndarray or list, optional
| Import an array of data with the legacy :vtk:`vtkCellArray` layout, e.g.
| ``{ n0, p0_0, p0_1, ..., p0_n, n1, p1_0, p1_1, ..., p1_n, ... }``
| Where n0 is the number of points in cell 0, and pX_Y is the Y'th
| point in cell X.
|
| Examples
| --------
| Create a cell array containing two triangles from the traditional interleaved format
|
| >>> from pyvista.core.cell import CellArray
| >>> cellarr = CellArray([3, 0, 1, 2, 3, 3, 4, 5])
|
| Create a cell array containing two triangles from separate offsets and connectivity arrays
|
| >>> from pyvista.core.cell import CellArray
| >>> offsets = [0, 3, 6]
| >>> connectivity = [0, 1, 2, 3, 4, 5]
| >>> cellarr = CellArray.from_arrays(offsets, connectivity)
|
| Method resolution order:
| CellArray
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkCellArray
| vtkmodules.vtkCommonDataModel.vtkAbstractCellArray
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'Self', cells: 'CellsLike | None' = None) -> 'None'
| Initialize a :vtk:`vtkCellArray`.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_irregular_cells(cells: 'MatrixLike[int]') -> 'CellArray'
| Construct a ``CellArray`` from a (n_cells, cell_size) array of cell indices.
|
| Parameters
| ----------
| cells : numpy.ndarray or list[list[int]]
| Cell array of shape (n_cells, cell_size) where all cells have the same `cell_size`.
|
| Returns
| -------
| pyvista.CellArray
| Constructed ``CellArray``.
|
| from_regular_cells(cells: 'MatrixLike[int]', deep: 'bool' = False) -> 'CellArray'
| Construct a ``CellArray`` from a (n_cells, cell_size) array of cell indices.
|
| Parameters
| ----------
| cells : numpy.ndarray or list[list[int]]
| Cell array of shape (n_cells, cell_size) where all cells have the same `cell_size`.
|
| deep : bool, default: False
| Whether to deep copy the cell array data into the vtk connectivity array.
|
| Returns
| -------
| pyvista.CellArray
| Constructed ``CellArray``.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| from_arrays(offsets: 'MatrixLike[int]', connectivity: 'MatrixLike[int]', deep: 'bool' = False) -> 'CellArray'
| Construct a CellArray from offsets and connectivity arrays.
|
| Parameters
| ----------
| offsets : MatrixLike[int]
| Offsets array of length `n_cells + 1`.
|
| connectivity : MatrixLike[int]
| Connectivity array.
|
| deep : bool, default: False
| Whether to deep copy the array data into the vtk arrays.
|
| Returns
| -------
| CellArray
| Constructed CellArray.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| connectivity_array
| Return the array with the point ids that define the cells' connectivity.
|
| Returns
| -------
| np.ndarray
| Array with the point ids that define the cells' connectivity.
|
| n_cells
| Return the number of cells.
|
| Returns
| -------
| int
| The number of cells.
|
| offset_array
| Return the array used to store cell offsets.
|
| Returns
| -------
| np.ndarray
| Array used to store cell offsets.
|
| regular_cells
| Return a (n_cells, cell_size)-shaped array of point indices for equal-sized faces.
|
| Returns
| -------
| numpy.ndarray
| Array of face indices of shape (n_cells, cell_size).
|
| Notes
| -----
| This property does not validate that the cells are all
| actually the same size. If they're not, this property may either
| raise a `ValueError` or silently return an incorrect array.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| cells
| Return a numpy array of the cells.
|
| Returns
| -------
| np.ndarray
| A numpy array of the cells.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkCellArray:
|
| Allocate(...)
| Allocate(self, sz:int, ext:int=1000) -> int
| C++: vtkTypeBool Allocate(vtkIdType sz, vtkIdType ext=1000)
|
| Allocate memory.
|
| This currently allocates both the offsets and connectivity arrays
| to sz.
|
| ote It is preferable to use AllocateEstimate(numCells,
| maxCellSize) or AllocateExact(numCells, connectivitySize)
| instead.
|
| AllocateCopy(...)
| AllocateCopy(self, other:vtkCellArray) -> bool
| C++: bool AllocateCopy(vtkCellArray *other)
|
| Pre-allocate memory in internal data structures to match the used
| size of the input vtkCellArray. Does not change the number of
| cells, only the array capacities. Existing data is NOT preserved.
| @param other The vtkCellArray to use as a reference.
| @return True if allocation succeeds.
| @sa Squeeze AllocateEstimate AllocateExact
|
| AllocateEstimate(...)
| AllocateEstimate(self, numCells:int, maxCellSize:int) -> bool
| C++: bool AllocateEstimate(vtkIdType numCells,
| vtkIdType maxCellSize)
|
| Pre-allocate memory in internal data structures. Does not change
| the number of cells, only the array capacities. Existing data is
| NOT preserved.
| @param numCells The number of expected cells in the dataset.
| @param maxCellSize The number of points per cell to allocate
| memory for.
| @return True if allocation succeeds.
| @sa Squeeze AllocateExact AllocateCopy
|
| AllocateExact(...)
| AllocateExact(self, numCells:int, connectivitySize:int) -> bool
| C++: bool AllocateExact(vtkIdType numCells,
| vtkIdType connectivitySize)
|
| Pre-allocate memory in internal data structures. Does not change
| the number of cells, only the array capacities. Existing data is
| NOT preserved.
| @param numCells The number of expected cells in the dataset.
| @param connectivitySize The total number of pointIds stored for
| all cells.
| @return True if allocation succeeds.
| @sa Squeeze AllocateEstimate AllocateCopy
|
| Append(...)
| Append(self, src:vtkCellArray, pointOffset:int=0) -> None
| C++: void Append(vtkCellArray *src, vtkIdType pointOffset=0)
|
| Append cells from src into this. Point ids are offset by
| pointOffset.
|
| AppendLegacyFormat(...)
| AppendLegacyFormat(self, data:vtkIdTypeArray, ptOffset:int=0)
| -> None
| C++: void AppendLegacyFormat(vtkIdTypeArray *data,
| vtkIdType ptOffset=0)
| AppendLegacyFormat(self, data:(int, ...), len:int, ptOffset:int=0)
| -> None
| C++: void AppendLegacyFormat(const vtkIdType *data, vtkIdType len,
| vtkIdType ptOffset=0)
|
| CanConvertTo32BitStorage(...)
| CanConvertTo32BitStorage(self) -> bool
| C++: bool CanConvertTo32BitStorage()
|
| CanConvertTo64BitStorage(...)
| CanConvertTo64BitStorage(self) -> bool
| C++: bool CanConvertTo64BitStorage()
|
| CanConvertToDefaultStorage(...)
| CanConvertToDefaultStorage(self) -> bool
| C++: bool CanConvertToDefaultStorage()
|
| CanConvertToFixedSize32BitStorage(...)
| CanConvertToFixedSize32BitStorage(self) -> bool
| C++: bool CanConvertToFixedSize32BitStorage()
|
| CanConvertToFixedSize64BitStorage(...)
| CanConvertToFixedSize64BitStorage(self) -> bool
| C++: bool CanConvertToFixedSize64BitStorage()
|
| CanConvertToFixedSizeDefaultStorage(...)
| CanConvertToFixedSizeDefaultStorage(self) -> bool
| C++: bool CanConvertToFixedSizeDefaultStorage()
|
| CanConvertToStorageType(...)
| CanConvertToStorageType(self, type:StorageTypes) -> bool
| C++: bool CanConvertToStorageType(StorageTypes type)
|
| ConvertTo32BitStorage(...)
| ConvertTo32BitStorage(self) -> bool
| C++: bool ConvertTo32BitStorage()
|
| ConvertTo64BitStorage(...)
| ConvertTo64BitStorage(self) -> bool
| C++: bool ConvertTo64BitStorage()
|
| ConvertToDefaultStorage(...)
| ConvertToDefaultStorage(self) -> bool
| C++: bool ConvertToDefaultStorage()
|
| ConvertToFixedSize32BitStorage(...)
| ConvertToFixedSize32BitStorage(self) -> bool
| C++: bool ConvertToFixedSize32BitStorage()
|
| ConvertToFixedSize64BitStorage(...)
| ConvertToFixedSize64BitStorage(self) -> bool
| C++: bool ConvertToFixedSize64BitStorage()
|
| ConvertToFixedSizeDefaultStorage(...)
| ConvertToFixedSizeDefaultStorage(self) -> bool
| C++: bool ConvertToFixedSizeDefaultStorage()
|
| ConvertToSmallestStorage(...)
| ConvertToSmallestStorage(self) -> bool
| C++: bool ConvertToSmallestStorage()
|
| ConvertToStorageType(...)
| ConvertToStorageType(self, type:StorageTypes) -> bool
| C++: bool ConvertToStorageType(StorageTypes type)
|
| DeepCopy(...)
| DeepCopy(self, ca:vtkAbstractCellArray) -> None
| C++: void DeepCopy(vtkAbstractCellArray *ca) override;
|
| Perform a deep copy (no reference counting) of the given cell
| array.
|
| EstimateSize(...)
| EstimateSize(self, numCells:int, maxPtsPerCell:int) -> int
| C++: vtkIdType EstimateSize(vtkIdType numCells, int maxPtsPerCell)
|
| Utility routines help manage memory of cell array. EstimateSize()
| returns a value used to initialize and allocate memory for array
| based on number of cells and maximum number of points making up
| cell. If every cell is the same size (in terms of number of
| points), then the memory estimate is guaranteed exact. (If not
| exact, use Squeeze() to reclaim any extra memory.)
|
| ote This method was often misused (e.g. called alone and then
| discarding the result). Use AllocateEstimate directly instead.
|
| ExportLegacyFormat(...)
| ExportLegacyFormat(self, data:vtkIdTypeArray) -> None
| C++: void ExportLegacyFormat(vtkIdTypeArray *data)
|
| Fill data with the old-style vtkCellArray data layout, e.g.
|
| ``` { n0, p0_0, p0_1, ..., p0_n, n1, p1_0, p1_1, ..., p1_n, ... }
| ```
|
| where `n0` is the number of points in cell 0, and `pX_Y` is the
| Y'th point in cell X.
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize()
|
| Return the memory in kibibytes (1024 bytes) consumed by this cell
| array. Used to support streaming and reading/writing data. The
| value returned is guaranteed to be greater than or equal to the
| memory required to actually represent the data represented by
| this object. The information returned is valid only after the
| pipeline has been updated.
|
| GetCell(...)
| GetCell(self, loc:int, npts:int, pts:(int, ...)) -> None
| C++: void GetCell(vtkIdType loc, vtkIdType &npts,
| const vtkIdType *&pts)
| GetCell(self, loc:int, pts:vtkIdList) -> None
| C++: void GetCell(vtkIdType loc, vtkIdList *pts)
|
| Internal method used to retrieve a cell given a legacy offset
| location.
|
| @warning Subsequent calls to this method may invalidate previous
| call
| results.
|
| ote The location-based API is now a super-slow compatibility
| layer. Prefer GetCellAtId.
|
| GetCellAtId(...)
| GetCellAtId(self, cellId:int, cellSize:int, cellPoints:(int, ...),
| ptIds:vtkIdList) -> None
| C++: void GetCellAtId(vtkIdType cellId, vtkIdType &cellSize,
| vtkIdType const *&cellPoints, vtkIdList *ptIds) override;
| GetCellAtId(self, cellId:int, pts:vtkIdList) -> None
| C++: void GetCellAtId(vtkIdType cellId, vtkIdList *pts) override;
| GetCellAtId(self, cellId:int, cellSize:int, cellPoints:[int, ...])
| -> None
| C++: void GetCellAtId(vtkIdType cellId, vtkIdType &cellSize,
| vtkIdType *cellPoints) override;
| GetCellAtId(self, cellId:int, cellSize:int, cellPoints:(int, ...))
| -> None
| C++: void GetCellAtId(vtkIdType cellId, vtkIdType &cellSize,
| vtkIdType const *&cellPoints)
|
| Return the point ids for the cell at cellId.
|
| Subsequent calls to this method may invalidate previous call
| results if the internal storage type is not the same as vtkIdType
| and cannot be shared through the cellPoints pointer. If that
| occurs, the method will use ptIds, which is an object that is
| created by each thread, to guarantee thread safety.
|
| GetCellPointAtId(...)
| GetCellPointAtId(self, cellId:int, cellPointIndex:int) -> int
| C++: vtkIdType GetCellPointAtId(vtkIdType cellId,
| vtkIdType cellPointIndex)
|
| Return the point id at cellPointIndex for the cell at cellId.
|
| GetCellSize(...)
| GetCellSize(self, cellId:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType cellId) override;
|
| Return the size of the cell at cellId.
|
| GetConnectivityAOSArray32(...)
| GetConnectivityAOSArray32(self)
| -> vtkAOSDataArrayTemplate_I12vtkTypeInt32E
| C++: AOSArray32 *GetConnectivityAOSArray32()
|
| GetConnectivityAOSArray64(...)
| GetConnectivityAOSArray64(self)
| -> vtkAOSDataArrayTemplate_I12vtkTypeInt64E
| C++: AOSArray64 *GetConnectivityAOSArray64()
|
| GetConnectivityArray(...)
| GetConnectivityArray(self) -> vtkDataArray
| C++: vtkDataArray *GetConnectivityArray()
|
| GetConnectivityArray32(...)
| GetConnectivityArray32(self) -> vtkTypeInt32Array
| C++: vtkTypeInt32Array *GetConnectivityArray32()
|
| GetConnectivityArray64(...)
| GetConnectivityArray64(self) -> vtkTypeInt64Array
| C++: vtkTypeInt64Array *GetConnectivityArray64()
|
| GetData(...)
| GetData(self) -> vtkIdTypeArray
| C++: vtkIdTypeArray *GetData()
|
| Return the underlying data as a data array.
|
| @warning The returned array is not the actual internal
| representation used
| by vtkCellArray. Modifications to the returned array will not
| change the vtkCellArray's topology.
|
| ote Use ExportLegacyFormat, or
| GetOffsetsArray/GetConnectivityArray instead.
|
| GetDefaultStorageIs64Bit(...)
| GetDefaultStorageIs64Bit() -> bool
| C++: static bool GetDefaultStorageIs64Bit()
|
| GetInsertLocation(...)
| GetInsertLocation(self, npts:int) -> int
| C++: vtkIdType GetInsertLocation(int npts)
|
| Computes the current legacy insertion location within the
| internal array. Used in conjunction with GetCell(int loc,...).
|
| ote The location-based API is now a super-slow compatibility
| layer.
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Returns the size of the largest cell. The size is the number of
| points defining the cell.
|
| GetNextCell(...)
| GetNextCell(self, npts:int, pts:(int, ...)) -> int
| C++: int GetNextCell(vtkIdType &npts, vtkIdType const *&pts)
| GetNextCell(self, pts:vtkIdList) -> int
| C++: int GetNextCell(vtkIdList *pts)
|
| @warning This method is not thread-safe. Consider using the
| NewIterator()
| iterator instead.
|
| GetNextCell() gets the next cell in the list. If end of list is
| encountered, 0 is returned. A value of 1 is returned whenever
| npts and pts have been updated without error.
|
| Do not modify the returned pts pointer, as it may point to shared
| memory.
|
| ote This method is not thread-safe and has tricky syntax to use
| correctly. Prefer the use of vtkCellArrayIterator (see
| NewIterator()).
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| Get the number of cells in the array.
|
| GetNumberOfConnectivityEntries(...)
| GetNumberOfConnectivityEntries(self) -> int
| C++: vtkIdType GetNumberOfConnectivityEntries()
|
| Return the size of the array that would be returned from
| ExportLegacyFormat().
|
| ote Method incompatible with current internal storage.
|
| GetNumberOfConnectivityIds(...)
| GetNumberOfConnectivityIds(self) -> int
| C++: vtkIdType GetNumberOfConnectivityIds() override;
|
| Get the size of the connectivity array that stores the point ids.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfOffsets(...)
| GetNumberOfOffsets(self) -> int
| C++: vtkIdType GetNumberOfOffsets() override;
|
| Get the number of elements in the offsets array. This will be the
| number of cells + 1.
|
| GetOffset(...)
| GetOffset(self, cellId:int) -> int
| C++: vtkIdType GetOffset(vtkIdType cellId) override;
|
| Get the offset (into the connectivity) for a specified cell id.
|
| GetOffsetsAOSArray32(...)
| GetOffsetsAOSArray32(self)
| -> vtkAOSDataArrayTemplate_I12vtkTypeInt32E
| C++: AOSArray32 *GetOffsetsAOSArray32()
|
| GetOffsetsAOSArray64(...)
| GetOffsetsAOSArray64(self)
| -> vtkAOSDataArrayTemplate_I12vtkTypeInt64E
| C++: AOSArray64 *GetOffsetsAOSArray64()
|
| GetOffsetsAffineArray32(...)
| GetOffsetsAffineArray32(self) -> vtkAffineArray_I12vtkTypeInt32E
| C++: AffineArray32 *GetOffsetsAffineArray32()
|
| GetOffsetsAffineArray64(...)
| GetOffsetsAffineArray64(self) -> vtkAffineArray_I12vtkTypeInt64E
| C++: AffineArray64 *GetOffsetsAffineArray64()
|
| GetOffsetsArray(...)
| GetOffsetsArray(self) -> vtkDataArray
| C++: vtkDataArray *GetOffsetsArray()
|
| GetOffsetsArray32(...)
| GetOffsetsArray32(self) -> vtkTypeInt32Array
| C++: vtkTypeInt32Array *GetOffsetsArray32()
|
| GetOffsetsArray64(...)
| GetOffsetsArray64(self) -> vtkTypeInt64Array
| C++: vtkTypeInt64Array *GetOffsetsArray64()
|
| GetSize(...)
| GetSize(self) -> int
| C++: vtkIdType GetSize()
|
| Get the size of the allocated connectivity array.
|
| @warning This returns the allocated capacity of the internal
| arrays as a
| number of elements, NOT the number of elements in use.
|
| ote Method incompatible with current internal storage.
|
| GetStorageType(...)
| GetStorageType(self) -> StorageTypes
| C++: StorageTypes GetStorageType() noexcept;
|
| @return Type of internal storage.
|
| GetTraversalCellId(...)
| GetTraversalCellId(self) -> int
| C++: vtkIdType GetTraversalCellId()
|
| GetTraversalLocation(...)
| GetTraversalLocation(self) -> int
| C++: vtkIdType GetTraversalLocation()
| GetTraversalLocation(self, npts:int) -> int
| C++: vtkIdType GetTraversalLocation(vtkIdType npts)
|
| ImportLegacyFormat(...)
| ImportLegacyFormat(self, data:vtkIdTypeArray) -> None
| C++: void ImportLegacyFormat(vtkIdTypeArray *data)
| ImportLegacyFormat(self, data:(int, ...), len:int) -> None
| C++: void ImportLegacyFormat(const vtkIdType *data, vtkIdType len)
|
| InitTraversal(...)
| InitTraversal(self) -> None
| C++: void InitTraversal()
|
| @warning This method is not thread-safe. Consider using the
| NewIterator()
| iterator instead.
|
| InitTraversal() initializes the traversal of the list of cells.
|
| ote This method is not thread-safe and has tricky syntax to use
| correctly. Prefer the use of vtkCellArrayIterator (see
| NewIterator()).
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Free any memory and reset to an empty state.
|
| InsertCellPoint(...)
| InsertCellPoint(self, id:int) -> None
| C++: void InsertCellPoint(vtkIdType id)
|
| Used in conjunction with InsertNextCell(npts) to add another
| point to the list of cells.
|
| InsertNextCell(...)
| InsertNextCell(self, cell:vtkCell) -> int
| C++: vtkIdType InsertNextCell(vtkCell *cell)
| InsertNextCell(self, npts:int, pts:(int, ...)) -> int
| C++: vtkIdType InsertNextCell(vtkIdType npts,
| const vtkIdType *pts)
| InsertNextCell(self, pts:vtkIdList) -> int
| C++: vtkIdType InsertNextCell(vtkIdList *pts)
| InsertNextCell(self, npts:int) -> int
| C++: vtkIdType InsertNextCell(int npts)
|
| Insert a cell object. Return the cell id of the cell.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsHomogeneous(...)
| IsHomogeneous(self) -> int
| C++: vtkIdType IsHomogeneous() override;
|
| Check if all cells have the same number of vertices.
|
| The return value is coded as:
| * -1 = heterogeneous
| * 0 = Cell array empty
| * n (positive integer) = homogeneous array of cell size n
|
| IsStorage32Bit(...)
| IsStorage32Bit(self) -> bool
| C++: bool IsStorage32Bit()
|
| @return True if the internal storage is using 32 bit arrays.
|
| IsStorage64Bit(...)
| IsStorage64Bit(self) -> bool
| C++: bool IsStorage64Bit()
|
| @return True if the internal storage is using 64 bit arrays.
|
| IsStorageFixedSize(...)
| IsStorageFixedSize(self) -> bool
| C++: bool IsStorageFixedSize()
|
| @return True if the internal storage is using FixedSize arrays.
|
| IsStorageFixedSize32Bit(...)
| IsStorageFixedSize32Bit(self) -> bool
| C++: bool IsStorageFixedSize32Bit()
|
| @return True if the internal storage is using FixedSize 32 bit
| arrays.
|
| IsStorageFixedSize64Bit(...)
| IsStorageFixedSize64Bit(self) -> bool
| C++: bool IsStorageFixedSize64Bit()
|
| @return True if the internal storage is using FixedSize 64 bit
| arrays.
|
| IsStorageGeneric(...)
| IsStorageGeneric(self) -> bool
| C++: bool IsStorageGeneric()
|
| @return True if the internal storage is using vtkDataArray.
|
| IsStorageShareable(...)
| IsStorageShareable(self) -> bool
| C++: bool IsStorageShareable() override;
|
| @return True if the internal storage can be shared as a
| pointer to vtkIdType, i.e., the type and organization of internal
| storage is such that copying of data can be avoided, and instead
| a pointer to vtkIdType can be used.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsValid(...)
| IsValid(self) -> bool
| C++: bool IsValid()
|
| Check that internal storage is consistent and in a valid state.
|
| Specifically, this function returns true if and only if:
| - The offset and connectivity arrays have exactly one component.
| - The offset array has at least one value and starts at 0.
| - The offset array values never decrease.
| - The connectivity array has as many entries as the last value in
| the offset array.
|
| NewInstance(...)
| NewInstance(self) -> vtkCellArray
| C++: vtkCellArray *NewInstance()
|
| NewIterator(...)
| NewIterator(self) -> vtkCellArrayIterator
| C++: vtkCellArrayIterator *NewIterator()
|
| NewIterator returns a new instance of vtkCellArrayIterator that
| is initialized to point at the first cell's data. The caller is
| responsible for Delete()'ing the object.
|
| ReplaceCell(...)
| ReplaceCell(self, loc:int, npts:int, pts:(int, ...)) -> None
| C++: void ReplaceCell(vtkIdType loc, int npts,
| const vtkIdType pts[])
|
| Replace the point ids of the cell at the legacy location with a
| different list of point ids. Calling this method does not mark
| the vtkCellArray as modified. This is the responsibility of the
| caller and may be done after multiple calls to ReplaceCell. This
| call does not support changing the number of points in the cell
| -- the caller must ensure that the target cell has npts points.
|
| ote The location-based API is now a super-slow compatibility
| layer. Prefer ReplaceCellAtId.
|
| ReplaceCellAtId(...)
| ReplaceCellAtId(self, cellId:int, list:vtkIdList) -> None
| C++: void ReplaceCellAtId(vtkIdType cellId, vtkIdList *list)
| ReplaceCellAtId(self, cellId:int, cellSize:int, cellPoints:(int,
| ...)) -> None
| C++: void ReplaceCellAtId(vtkIdType cellId, vtkIdType cellSize,
| const vtkIdType *cellPoints)
|
| ReplaceCellPointAtId(...)
| ReplaceCellPointAtId(self, cellId:int, cellPointIndex:int,
| newPointId:int) -> None
| C++: void ReplaceCellPointAtId(vtkIdType cellId,
| vtkIdType cellPointIndex, vtkIdType newPointId)
|
| Replaces the pointId at cellPointIndex of a cell with newPointId.
|
| @warning This can ONLY replace the cell if the size does not
| change.
| Attempting to change cell size through this method will have
| undefined results.
|
| Reset(...)
| Reset(self) -> None
| C++: void Reset()
|
| Reuse list. Reset to initial state without freeing memory.
|
| ResizeExact(...)
| ResizeExact(self, numCells:int, connectivitySize:int) -> bool
| C++: bool ResizeExact(vtkIdType numCells,
| vtkIdType connectivitySize)
|
| ResizeExact() resizes the internal structures to hold numCells
| total cell offsets and connectivitySize total pointIds. Old data
| is preserved, and newly-available memory is not initialized.
|
| @warning For advanced use only. You probably want an Allocate
| method.
|
| @return True if allocation succeeds.
|
| ReverseCell(...)
| ReverseCell(self, loc:int) -> None
| C++: void ReverseCell(vtkIdType loc)
|
| Special method inverts ordering of cell at the specified legacy
| location. Must be called carefully or the cell topology may be
| corrupted.
|
| ote The location-based API is now a super-slow compatibility
| layer. Prefer ReverseCellAtId;
|
| ReverseCellAtId(...)
| ReverseCellAtId(self, cellId:int) -> None
| C++: void ReverseCellAtId(vtkIdType cellId)
|
| Reverses the order of the point ids for the specified cell.
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkCellArray
| C++: static vtkCellArray *SafeDownCast(vtkObjectBase *o)
|
| SetCells(...)
| SetCells(self, ncells:int, cells:vtkIdTypeArray) -> None
| C++: void SetCells(vtkIdType ncells, vtkIdTypeArray *cells)
|
| Define multiple cells by providing a connectivity list. The list
| is in the form (npts,p0,p1,...p(npts-1), repeated for each cell).
| Be careful using this method because it discards the old cells,
| and anything referring these cells becomes invalid (for example,
| if BuildCells() has been called see vtkPolyData). The traversal
| location is reset to the beginning of the list; the insertion
| location is set to the end of the list.
|
| @warning The vtkCellArray will not hold a reference to `cells`.
| This
| function merely calls ImportLegacyFormat.
|
| ote Use ImportLegacyFormat or SetData instead.
|
| SetData(...)
| SetData(self, __a:vtkAOSDataArrayTemplate_I12vtkTypeInt32E,
| connectivity:vtkAOSDataArrayTemplate_I12vtkTypeInt32E) -> None
| C++: void SetData(AOSArray32 *, AOSArray32 *connectivity)
| SetData(self, __a:vtkAOSDataArrayTemplate_I12vtkTypeInt64E,
| connectivity:vtkAOSDataArrayTemplate_I12vtkTypeInt64E) -> None
| C++: void SetData(AOSArray64 *, AOSArray64 *connectivity)
| SetData(self, __a:vtkAffineArray_I12vtkTypeInt32E,
| connectivity:vtkAOSDataArrayTemplate_I12vtkTypeInt32E) -> None
| C++: void SetData(AffineArray32 *, AOSArray32 *connectivity)
| SetData(self, __a:vtkAffineArray_I12vtkTypeInt64E,
| connectivity:vtkAOSDataArrayTemplate_I12vtkTypeInt64E) -> None
| C++: void SetData(AffineArray64 *, AOSArray64 *connectivity)
| SetData(self, offsets:vtkDataArray, connectivity:vtkDataArray)
| -> bool
| C++: bool SetData(vtkDataArray *offsets,
| vtkDataArray *connectivity)
| SetData(self, cellSize:int, connectivity:vtkDataArray) -> bool
| C++: bool SetData(vtkIdType cellSize, vtkDataArray *connectivity)
|
| Set the internal data arrays to the supplied offsets and
| connectivity arrays.
|
| For connectivity use vtkCellArray::AOSArray32, or
| vtkCellArray::AOSArray64, which are part of
| vtkArrayDispatch::ConnectivityArrays.
|
| For offsets use vtkCellArray::AOSArray32,
| vtkCellArray::AOSArray64, vtkCellArray::AffineArray32 or
| vtkCellArray::AffineArray64, which are part of
| vtkArrayDispatch::OffsetsArrays.
|
| If the arrays are nullptr, or they don't have 1 component, an
| error is logged.
|
| SetDefaultStorageIs64Bit(...)
| SetDefaultStorageIs64Bit(val:bool) -> None
| C++: static void SetDefaultStorageIs64Bit(bool val)
|
| SetNumberOfCells(...)
| SetNumberOfCells(self, __a:int) -> None
| C++: virtual void SetNumberOfCells(vtkIdType)
|
| Set the number of cells in the array. DO NOT do any kind of
| allocation, advanced use only.
|
| ote This call has no effect.
|
| SetOffset(...)
| SetOffset(self, cellId:int, offset:int) -> None
| C++: void SetOffset(vtkIdType cellId, vtkIdType offset)
|
| Set the offset (into the connectivity) for a specified cell id.
|
| SetTraversalCellId(...)
| SetTraversalCellId(self, cellId:int) -> None
| C++: void SetTraversalCellId(vtkIdType cellId)
|
| SetTraversalLocation(...)
| SetTraversalLocation(self, loc:int) -> None
| C++: void SetTraversalLocation(vtkIdType loc)
|
| ShallowCopy(...)
| ShallowCopy(self, ca:vtkAbstractCellArray) -> None
| C++: void ShallowCopy(vtkAbstractCellArray *ca) override;
|
| Shallow copy ca into this cell array.
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: void Squeeze()
|
| Reclaim any extra memory while preserving data.
|
| @sa ConvertToSmallestStorage
|
| UpdateCellCount(...)
| UpdateCellCount(self, npts:int) -> None
| C++: void UpdateCellCount(int npts)
|
| Used in conjunction with InsertNextCell(int npts) and
| InsertCellPoint() to update the number of points defining the
| cell.
|
| Use32BitStorage(...)
| Use32BitStorage(self) -> None
| C++: void Use32BitStorage()
|
| Use64BitStorage(...)
| Use64BitStorage(self) -> None
| C++: void Use64BitStorage()
|
| UseDefaultStorage(...)
| UseDefaultStorage(self) -> None
| C++: void UseDefaultStorage()
|
| UseFixedSize32BitStorage(...)
| UseFixedSize32BitStorage(self, cellSize:int) -> None
| C++: void UseFixedSize32BitStorage(vtkIdType cellSize)
|
| UseFixedSize64BitStorage(...)
| UseFixedSize64BitStorage(self, cellSize:int) -> None
| C++: void UseFixedSize64BitStorage(vtkIdType cellSize)
|
| UseFixedSizeDefaultStorage(...)
| UseFixedSizeDefaultStorage(self, cellSize:int) -> None
| C++: void UseFixedSizeDefaultStorage(vtkIdType cellSize)
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkCommonDataModel.vtkCellArray:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkCommonDataModel.vtkCellArray
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkCellArray:
|
| __this__
| Pointer to the C++ object.
|
| actual_memory_size
| read-only, calls GetActualMemorySize
|
| connectivity_aos_array32
| read-only, calls GetConnectivityAOSArray32
|
| connectivity_aos_array64
| read-only, calls GetConnectivityAOSArray64
|
| connectivity_array32
| read-only, calls GetConnectivityArray32
|
| connectivity_array64
| read-only, calls GetConnectivityArray64
|
| data
| read-only, calls GetData
|
| default_storage_is64_bit
| read-write, calls GetDefaultStorageIs64Bit/SetDefaultStorageIs64Bit
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| number_of_cells
| read-write, calls GetNumberOfCells/SetNumberOfCells
|
| number_of_connectivity_entries
| read-only, calls GetNumberOfConnectivityEntries
|
| number_of_connectivity_ids
| read-only, calls GetNumberOfConnectivityIds
|
| number_of_offsets
| read-only, calls GetNumberOfOffsets
|
| offsets_affine_array32
| read-only, calls GetOffsetsAffineArray32
|
| offsets_affine_array64
| read-only, calls GetOffsetsAffineArray64
|
| offsets_aos_array32
| read-only, calls GetOffsetsAOSArray32
|
| offsets_aos_array64
| read-only, calls GetOffsetsAOSArray64
|
| offsets_array
| read-only, calls GetOffsetsArray
|
| offsets_array32
| read-only, calls GetOffsetsArray32
|
| offsets_array64
| read-only, calls GetOffsetsArray64
|
| size
| read-only, calls GetSize
|
| storage_type
| read-only, calls GetStorageType
|
| traversal_cell_id
| read-write, calls GetTraversalCellId/SetTraversalCellId
|
| traversal_location
| read-write, calls GetTraversalLocation/SetTraversalLocation
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkCellArray:
|
| FixedSizeInt32 = 3
|
| FixedSizeInt64 = 2
|
| Generic = 4
|
| Int32 = 1
|
| Int64 = 0
|
| StorageTypes = <class 'vtkmodules.vtkCommonDataModel.vtkCellArray.Stor...
|
| __vtkname__ = 'vtkCellArray'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
DATA
TYPE_CHECKING = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\cell.py
pyvista.cell_array
Python Library Documentation: function cell_array in module pyvista.core.utilities.arrays
cell_array(obj: 'DataSet | _vtk.vtkDataSet', name: 'str') -> 'pyvista_ndarray | None'
Return cell array of a pyvista or vtk object.
Parameters
----------
obj : DataSet | :vtk:`vtkDataSet`
PyVista or VTK dataset.
name : str | int
Name or index of the array.
Returns
-------
output : pyvista.pyvista_ndarray | None
Wrapped array if the index or name is valid. Otherwise, ``None``.
pyvista.cell_quality
Python Library Documentation: module pyvista.core.utilities.cell_quality in pyvista.core.utilities
NAME
pyvista.core.utilities.cell_quality - Information about cell quality measures.
CLASSES
pyvista.core.utilities.misc._NoNewAttrMixin(builtins.object)
CellQualityInfo
class CellQualityInfo(pyvista.core.utilities.misc._NoNewAttrMixin)
| CellQualityInfo(*args, **kwargs) -> '_T'
|
| Information about a cell's quality measure.
|
| Method resolution order:
| CellQualityInfo
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __init__(self, cell_type: '_CellTypesLiteral', quality_measure: '_CellQualityLiteral', acceptable_range: 'tuple[float, float]', normal_range: 'tuple[float, float]', full_range: 'tuple[float, float]', unit_cell_value: 'float') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'acceptable_range': 'tuple[float, float]', 'cell_ty...
|
| __dataclass_fields__ = {'acceptable_range': Field(name='acceptable_ran...
|
| __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
|
| __hash__ = None
|
| __match_args__ = ('cell_type', 'quality_measure', 'acceptable_range', ...
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
Info = class CellQualityInfo(pyvista.core.utilities.misc._NoNewAttrMixin)
| Info(*args, **kwargs) -> '_T'
|
| Information about a cell's quality measure.
|
| Method resolution order:
| CellQualityInfo
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __init__(self, cell_type: '_CellTypesLiteral', quality_measure: '_CellQualityLiteral', acceptable_range: 'tuple[float, float]', normal_range: 'tuple[float, float]', full_range: 'tuple[float, float]', unit_cell_value: 'float') -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'acceptable_range': 'tuple[float, float]', 'cell_ty...
|
| __dataclass_fields__ = {'acceptable_range': Field(name='acceptable_ran...
|
| __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
|
| __hash__ = None
|
| __match_args__ = ('cell_type', 'quality_measure', 'acceptable_range', ...
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
cell_quality_info(cell_type: '_CellTypesLiteral | _CellTypeNamesLiteral', quality_measure: '_CellQualityLiteral') -> 'CellQualityInfo'
Return information about a cell's quality measure.
This function returns information about a quality measure computed by
:meth:`~pyvista.DataObjectFilters.cell_quality` for a specified
:class:`~pyvista.CellType`. The following is provided for each measure:
- ``acceptable_range``: Well-behaved cells have values in this range.
- ``normal_range``: All cells except those with degeneracies have values in this range.
- ``full_range``: All cells including degenerate ones have values in this range.
- ``unit_cell_value``: The quality measure value for a reference unit cell (e.g.
equilateral triangle with edge length of one for triangles).
This information can help inform if a particular cell is of high or low quality.
See the tables below for a summary of all cell quality info available from this
function.
.. include:: /api/core/cell_quality/cell_quality_info_table_TRIANGLE.rst
.. include:: /api/core/cell_quality/cell_quality_info_table_QUAD.rst
.. include:: /api/core/cell_quality/cell_quality_info_table_HEXAHEDRON.rst
.. include:: /api/core/cell_quality/cell_quality_info_table_TETRA.rst
.. include:: /api/core/cell_quality/cell_quality_info_table_WEDGE.rst
.. include:: /api/core/cell_quality/cell_quality_info_table_PYRAMID.rst
.. note::
The information returned by this function is based on the
`Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_.
.. note::
Information is not available for all valid quality measures computed by
:meth:`~pyvista.DataObjectFilters.cell_quality`. Only a subset
is provided here. If information about a measure is missing and you have
knowledge about its acceptable range, normal range, etc., please consider
submitting a pull request on GitHub at https://github.com/pyvista/pyvista.
Parameters
----------
cell_type : CellType | str
Cell type to get information about. May be a :class:`~pyvista.CellType` or the
name of a cell type as a string.
quality_measure : str
Quality measure to get information about. May be any quality measure from
:ref:`cell_quality_measures_table`.
Returns
-------
CellQualityInfo
Dataclass with information about the quality measure for a specific cell type.
Raises
------
ValueError
If info is not available for the specified cell type or measure.
See Also
--------
:meth:`~pyvista.DataObjectFilters.cell_quality`
Examples
--------
Get cell quality info for :attr:`~pyvista.CellType.TRIANGLE` cells and the
``'scaled_jacobian'`` quality measure.
>>> import pyvista as pv
>>> info_tri = pv.cell_quality_info(pv.CellType.TRIANGLE, 'scaled_jacobian')
>>> info_tri # doctest: +NORMALIZE_WHITESPACE
CellQualityInfo(cell_type=<CellType.TRIANGLE: 5>,
quality_measure='scaled_jacobian',
acceptable_range=(0.5, 1.1547005383792515),
normal_range=(-1.1547005383792515, 1.1547005383792515),
full_range=(-inf, inf),
unit_cell_value=1.0)
Show the acceptable range for this measure.
>>> info_tri.acceptable_range
(0.5, 1.1547005383792515)
Show the value of this measure for equilateral triangles with edge length of one.
>>> info_tri.unit_cell_value
1.0
Get info for the same measure but for :attr:`~pyvista.CellType.QUAD` cells.
>>> info_quad = pv.cell_quality_info(pv.CellType.QUAD, 'scaled_jacobian')
>>> info_quad # doctest: +NORMALIZE_WHITESPACE
CellQualityInfo(cell_type=<CellType.QUAD: 9>,
quality_measure='scaled_jacobian',
acceptable_range=(0.3, 1.0),
normal_range=(-1.0, 1.0),
full_range=(-1.0, 1.0),
unit_cell_value=1.0)
Show the acceptable range. Note that it differs for quads compared to triangles.
>>> info_quad.acceptable_range
(0.3, 1.0)
Show the value of this measure for a square cell with edge length of one.
>>> info_quad.unit_cell_value
1.0
See :ref:`mesh_quality_example` for more examples using this function.
sqrt(num: 'float') -> 'float'
DATA
ANGLE = 70.52877936550931
HEXAHEDRON = <CellType.HEXAHEDRON: 12>
.. grid:: 1 2 2 2
:reverse:
:margin: 1
.. grid-item::
:columns: 12 4 4 4
.. card::
:class-body: sd-px-0 sd-py-0 sd-rounded-3
:link: pyvista.examples.cells.Hexahedron
:link-type: any
.. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Hexahedron-IMAGE-HASH-PLACEHOLDER_00_00.png
.. grid-item::
:columns: 12 8 8 8
:bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
:bdg-link-muted:`Points: 8 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 12 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 6 <pyvista.CellType.n_faces>`
Represents a 3D rectangular hexahedron.
The hexahedron is a primary three-dimensional cell consisting of six
quadrilateral faces, twelve edges, and eight vertices.
See also :vtk:`vtkHexahedron`.
INF = inf
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
NoReturn = typing.NoReturn
Special type indicating functions that never return.
Example::
from typing import NoReturn
def stop() -> NoReturn:
raise Exception('no way')
NoReturn can also be used as a bottom type, a type that
has no values. Starting in Python 3.11, the Never type should
be used for this concept instead. Type checkers should treat the two
equivalently.
PYRAMID = <CellType.PYRAMID: 14>
.. grid:: 1 2 2 2
:reverse:
:margin: 1
.. grid-item::
:columns: 12 4 4 4
.. card::
:class-body: sd-px-0 sd-py-0 sd-rounded-3
:link: pyvista.examples.cells.Pyramid
:link-type: any
.. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Pyramid-IMAGE-HASH-PLACEHOLDER_00_00.png
.. grid-item::
:columns: 12 8 8 8
:bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
:bdg-link-muted:`Points: 5 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 8 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>`
Represents a 3D pyramid.
The pyramid is a primary three-dimensional cell consisting of a rectangular base
with four triangular faces. It is defined by an ordered list of five points.
See also :vtk:`vtkPyramid`.
QUAD = <CellType.QUAD: 9>
.. grid:: 1 2 2 2
:reverse:
:margin: 1
.. grid-item::
:columns: 12 4 4 4
.. card::
:class-body: sd-px-0 sd-py-0 sd-rounded-3
:link: pyvista.examples.cells.Quadrilateral
:link-type: any
.. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Quadrilateral-IMAGE-HASH-PLACEHOLDER_00_00.png
.. grid-item::
:columns: 12 8 8 8
:bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
:bdg-link-muted:`Points: 4 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 4 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
Represents a 2D quadrilateral.
The quadrilateral is a primary two-dimensional cell. It is defined by an ordered
list of four points lying in a plane.
See also :vtk:`vtkQuad`.
R22 = 0.7071067811865476
R33 = 0.5773502691896257
TETRA = <CellType.TETRA: 10>
.. grid:: 1 2 2 2
:reverse:
:margin: 1
.. grid-item::
:columns: 12 4 4 4
.. card::
:class-body: sd-px-0 sd-py-0 sd-rounded-3
:link: pyvista.examples.cells.Tetrahedron
:link-type: any
.. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Tetrahedron-IMAGE-HASH-PLACEHOLDER_00_00.png
.. grid-item::
:columns: 12 8 8 8
:bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
:bdg-link-muted:`Points: 4 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 6 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 4 <pyvista.CellType.n_faces>`
Represents a 3D tetrahedron.
The tetrahedron is a primary three-dimensional cell. The tetrahedron is defined
by a list of four non-planar points. It has six edges and four triangular faces.
See also :vtk:`vtkTetra`.
TRIANGLE = <CellType.TRIANGLE: 5>
.. grid:: 1 2 2 2
:reverse:
:margin: 1
.. grid-item::
:columns: 12 4 4 4
.. card::
:class-body: sd-px-0 sd-py-0 sd-rounded-3
:link: pyvista.examples.cells.Triangle
:link-type: any
.. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Triangle-IMAGE-HASH-PLACEHOLDER_00_00.png
.. grid-item::
:columns: 12 8 8 8
:bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
:bdg-link-muted:`Points: 3 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 3 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
Represents a 2D triangle.
The triangle is a primary two-dimensional cell. The triangle is defined by a
counter-clockwise ordered list of three points.
See also :vtk:`vtkTriangle`.
TYPE_CHECKING = False
WEDGE = <CellType.WEDGE: 13>
.. grid:: 1 2 2 2
:reverse:
:margin: 1
.. grid-item::
:columns: 12 4 4 4
.. card::
:class-body: sd-px-0 sd-py-0 sd-rounded-3
:link: pyvista.examples.cells.Wedge
:link-type: any
.. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Wedge-IMAGE-HASH-PLACEHOLDER_00_00.png
.. grid-item::
:columns: 12 8 8 8
:bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
:bdg-link-muted:`Points: 6 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 9 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>`
Represents a linear 3D wedge.
The wedge is a primary three-dimensional cell consisting of two triangular
and three quadrilateral faces.
See also :vtk:`vtkWedge`.
__annotations__ = {'HEXAHEDRON': 'Literal[CellType.HEXAHEDRON]', 'PYRA...
info = CellQualityInfo(cell_type=<CellType.WEDGE: 13>, ...=(-inf, inf)...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\cell_quality.py
pyvista.cell_quality_info
Python Library Documentation: function cell_quality_info in module pyvista.core.utilities.cell_quality
cell_quality_info(cell_type: '_CellTypesLiteral | _CellTypeNamesLiteral', quality_measure: '_CellQualityLiteral') -> 'CellQualityInfo'
Return information about a cell's quality measure.
This function returns information about a quality measure computed by
:meth:`~pyvista.DataObjectFilters.cell_quality` for a specified
:class:`~pyvista.CellType`. The following is provided for each measure:
- ``acceptable_range``: Well-behaved cells have values in this range.
- ``normal_range``: All cells except those with degeneracies have values in this range.
- ``full_range``: All cells including degenerate ones have values in this range.
- ``unit_cell_value``: The quality measure value for a reference unit cell (e.g.
equilateral triangle with edge length of one for triangles).
This information can help inform if a particular cell is of high or low quality.
See the tables below for a summary of all cell quality info available from this
function.
.. include:: /api/core/cell_quality/cell_quality_info_table_TRIANGLE.rst
.. include:: /api/core/cell_quality/cell_quality_info_table_QUAD.rst
.. include:: /api/core/cell_quality/cell_quality_info_table_HEXAHEDRON.rst
.. include:: /api/core/cell_quality/cell_quality_info_table_TETRA.rst
.. include:: /api/core/cell_quality/cell_quality_info_table_WEDGE.rst
.. include:: /api/core/cell_quality/cell_quality_info_table_PYRAMID.rst
.. note::
The information returned by this function is based on the
`Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_.
.. note::
Information is not available for all valid quality measures computed by
:meth:`~pyvista.DataObjectFilters.cell_quality`. Only a subset
is provided here. If information about a measure is missing and you have
knowledge about its acceptable range, normal range, etc., please consider
submitting a pull request on GitHub at https://github.com/pyvista/pyvista.
Parameters
----------
cell_type : CellType | str
Cell type to get information about. May be a :class:`~pyvista.CellType` or the
name of a cell type as a string.
quality_measure : str
Quality measure to get information about. May be any quality measure from
:ref:`cell_quality_measures_table`.
Returns
-------
CellQualityInfo
Dataclass with information about the quality measure for a specific cell type.
Raises
------
ValueError
If info is not available for the specified cell type or measure.
See Also
--------
:meth:`~pyvista.DataObjectFilters.cell_quality`
Examples
--------
Get cell quality info for :attr:`~pyvista.CellType.TRIANGLE` cells and the
``'scaled_jacobian'`` quality measure.
>>> import pyvista as pv
>>> info_tri = pv.cell_quality_info(pv.CellType.TRIANGLE, 'scaled_jacobian')
>>> info_tri # doctest: +NORMALIZE_WHITESPACE
CellQualityInfo(cell_type=<CellType.TRIANGLE: 5>,
quality_measure='scaled_jacobian',
acceptable_range=(0.5, 1.1547005383792515),
normal_range=(-1.1547005383792515, 1.1547005383792515),
full_range=(-inf, inf),
unit_cell_value=1.0)
Show the acceptable range for this measure.
>>> info_tri.acceptable_range
(0.5, 1.1547005383792515)
Show the value of this measure for equilateral triangles with edge length of one.
>>> info_tri.unit_cell_value
1.0
Get info for the same measure but for :attr:`~pyvista.CellType.QUAD` cells.
>>> info_quad = pv.cell_quality_info(pv.CellType.QUAD, 'scaled_jacobian')
>>> info_quad # doctest: +NORMALIZE_WHITESPACE
CellQualityInfo(cell_type=<CellType.QUAD: 9>,
quality_measure='scaled_jacobian',
acceptable_range=(0.3, 1.0),
normal_range=(-1.0, 1.0),
full_range=(-1.0, 1.0),
unit_cell_value=1.0)
Show the acceptable range. Note that it differs for quads compared to triangles.
>>> info_quad.acceptable_range
(0.3, 1.0)
Show the value of this measure for a square cell with edge length of one.
>>> info_quad.unit_cell_value
1.0
See :ref:`mesh_quality_example` for more examples using this function.
pyvista.cells
Python Library Documentation: module pyvista.core.utilities.cells in pyvista.core.utilities
NAME
pyvista.core.utilities.cells - PyVista wrapping of :vtk:`vtkCellArray`.
FUNCTIONS
create_mixed_cells(mixed_cell_dict: 'dict[np.uint8, NumpyArray[int]]', nr_points: 'int | None' = None) -> 'tuple[NumpyArray[np.uint8], NumpyArray[int]]'
Generate cell arrays for the creation of a pyvista.UnstructuredGrid from a cell dictionary.
This function generates all required cell arrays according to a given cell
dictionary. The given cell-dictionary should contain a proper
mapping of vtk_type -> np.ndarray (int), where the given ndarray
for each cell-type has to be an array of dimensions [N, D] or
[N*D], where N is the number of cells and D is the size of the
cells for the given type (e.g. 3 for triangles). Multiple
vtk_type keys with associated arrays can be present in one
dictionary. This function only accepts cell types of fixed size
and not dynamic sized cells like :attr:`~pyvista.CellType.POLYGON`
Parameters
----------
mixed_cell_dict : dict
A dictionary that maps VTK-Enum-types (e.g. :attr:`~pyvista.CellType.TRIANGLE`) to
np.ndarrays of type int. The ``np.ndarrays`` describe the cell
connectivity.
nr_points : int, optional
Number of points of the grid. Used only to allow additional runtime
checks for invalid indices.
Returns
-------
cell_types : numpy.ndarray (uint8)
Types of each cell.
cell_arr : numpy.ndarray (int)
VTK-cell array.
Raises
------
ValueError
If any of the cell types are not supported, have dynamic sized
cells, map to values with wrong size, or cell indices point
outside the given number of points.
Examples
--------
Create the cell arrays containing two triangles.
This will generate cell arrays to generate a mesh with two
disconnected triangles from 6 points.
>>> import numpy as np
>>> import vtk
>>> from pyvista.core.utilities.cells import create_mixed_cells
>>> cell_types, cell_arr = create_mixed_cells(
... {vtk.VTK_TRIANGLE: np.array([[0, 1, 2], [3, 4, 5]])}
... )
get_mixed_cells(vtkobj: 'UnstructuredGrid') -> 'dict[np.uint8, NumpyArray[int]]'
Create the cells dictionary from the given pyvista.UnstructuredGrid.
This functions creates a cells dictionary (see
create_mixed_cells), with a mapping vtk_type -> np.ndarray (int)
for fixed size cell types. The returned dictionary will have
arrays of size [N, D], where N is the number of cells and D is the
size of the cells for the given type (e.g. 3 for triangles).
.. versionchanged:: 0.46
An empty dict ``{}`` is returned instead of ``None`` if the input
is empty.
Parameters
----------
vtkobj : pyvista.UnstructuredGrid
The unstructured grid for which the cells dictionary should be computed.
Returns
-------
dict
Dictionary of cells.
Raises
------
ValueError
If vtkobj is not a pyvista.UnstructuredGrid, any of the
present cells are unsupported, or have dynamic cell sizes,
like VTK_POLYGON.
ncells_from_cells(cells: 'NumpyArray[int]') -> 'int'
Get the number of cells from a VTK cell connectivity array.
Parameters
----------
cells : numpy.ndarray
A VTK cell connectivity array.
Returns
-------
int
The number of cells extracted from the given cell connectivity array.
numpy_to_idarr(ind: 'int | ArrayLike[int]', deep: 'bool' = False, return_ind: 'bool' = False) -> 'tuple[_vtk.vtkIdTypeArray, NumpyArray[int]] | _vtk.vtkIdTypeArray'
Safely convert a numpy array to a :vtk:`vtkIdTypeArray`.
Parameters
----------
ind : sequence[int]
Input sequence to be converted to a :vtk:`vtkIdTypeArray`. Can be
either a mask or an integer array-like.
deep : bool, default: False
If ``True``, deep copy the input data. If ``False``, do not deep copy
the input data.
return_ind : bool, default: False
If ``True``, also return the input array after it has been cast to the
proper dtype.
Returns
-------
:vtk:`vtkIdTypeArray`
Converted array as a :vtk:`vtkIdTypeArray`.
numpy.ndarray
The input array after it has been cast to the proper dtype. Only
returned if `return_ind` is set to ``True``.
Raises
------
TypeError
If the input array is not a mask or an integer array-like.
DATA
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
TYPE_CHECKING = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\cells.py
pyvista.celltype
Python Library Documentation: module pyvista.core.celltype in pyvista.core
NAME
pyvista.core.celltype - Define types of cells.
CLASSES
enum.IntEnum(builtins.int, enum.ReprEnum)
CellType
class CellType(enum.IntEnum)
| CellType(*values)
|
| Define types of cells.
|
| Cells are defined by specifying a type in combination with an ordered list of points.
| The ordered list, often referred to as the connectivity list, combined with the
| type specification, implicitly defines the topology of the cell. The x-y-z point
| coordinates define the cell geometry.
|
| Although point coordinates are defined in three dimensions, the cell topology can
| be 0, 1, 2, or 3-dimensional. Use :attr:`dimension` to check the topological dimension.
|
| Cells can be primary (e.g. triangle) or composite (e.g. triangle strip). Composite
| cells consist of one or more primary cells, while primary cells cannot be
| decomposed. Use :attr:`is_composite` to check if a cell type is primary or composite.
|
| Cells can also be characterized as linear or non-linear. Linear cells use
| linear or constant interpolation, while non-linear cells may use quadratic,
| cubic, or some other interpolation. Use :attr:`is_linear` to check if a cell type is linear.
|
| Higher order interpolation is possible using Lagrange or Bézier cells. For Lagrange cells,
| all the points lie on the interpolation curve, whereas for the Bézier cells, only the points at
| the extremities are interpolatory.
|
| This enumeration defines all cell types used in VTK and supported by PyVista. The
| type(s) of cell(s) to use is typically chosen based on application need, such as
| graphics rendering or numerical simulation.
|
| .. seealso::
|
| :class:`pyvista.Cell`
| Wrapper for instances of :vtk:`vtkCell`.
|
| :mod:`pyvista.examples.cells`
| Examples creating a mesh comprising a single cell.
|
| :ref:`linear_cells_example`
| Detailed example using linear cells.
|
| :ref:`create_polyhedron_example`
| Example creating a mesh with :attr:`~pyvista.CellType.POLYHEDRON` cells.
|
| :ref:`create_polydata_strips_example`
| Example creating a mesh with :attr:`~pyvista.CellType.TRIANGLE_STRIP` cells.
|
| References
| ----------
| `VTK Book: Cell Types <https://book.vtk.org/en/latest/VTKBook/05Chapter5.html#cell-types>`_
| VTK reference about cell types.
|
| `Modeling Lagrange Finite Elements in VTK <https://www.kitware.com//modeling-arbitrary-order-lagrange-finite-elements-in-the-visualization-toolkit/>`_
| VTK blog post about Lagrange cells.
|
| `Implementation of rational Bézier cells into VTK <https://www.kitware.com/implementation-of-rational-bezier-cells-into-vtk/>`_
| VTK blog post about Bezier cells.
|
| `vtkCellType.h <https://vtk.org/doc/nightly/html/vtkCellType_8h_source.html>`_
| List of all cell types defined in VTK.
|
| Examples
| --------
| Create a single cube. Notice how the cell type is defined using the
| ``CellType``.
|
| >>> import numpy as np
| >>> from pyvista import CellType
| >>> import pyvista as pv
| >>> cells = np.array([8, 0, 1, 2, 3, 4, 5, 6, 7])
| >>> cell_type = np.array([CellType.HEXAHEDRON], np.int8)
| >>> points = np.array(
| ... [
| ... [0, 0, 0],
| ... [1, 0, 0],
| ... [1, 1, 0],
| ... [0, 1, 0],
| ... [0, 0, 1],
| ... [1, 0, 1],
| ... [1, 1, 1],
| ... [0, 1, 1],
| ... ],
| ... dtype=np.float32,
| ... )
| >>> grid = pv.UnstructuredGrid(cells, cell_type, points)
| >>> grid
| UnstructuredGrid (...)
| N Cells: 1
| N Points: 8
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 1.000e+00
| N Arrays: 0
|
| Method resolution order:
| CellType
| enum.IntEnum
| builtins.int
| enum.ReprEnum
| enum.Enum
| builtins.object
|
| Methods defined here:
|
| __format__(self, format_spec, /) from builtins.int
| Convert to a string according to format_spec.
|
| __new__(cls, value) from enum.Enum
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| BEZIER_CURVE = <CellType.BEZIER_CURVE: 75>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.BezierCurve
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BezierCurve-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`1D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Bezier representation of a curve with arbitrary order.
|
| See also :vtk:`vtkBezierCurve`.
|
|
| BEZIER_HEXAHEDRON = <CellType.BEZIER_HEXAHEDRON: 79>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.BezierHexahedron
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BezierHexahedron-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 12 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 6 <pyvista.CellType.n_faces>`
|
| Bezier representation of a hexahedron with arbitrary order.
|
| See also :vtk:`vtkBezierHexahedron`.
|
|
| BEZIER_PYRAMID = <CellType.BEZIER_PYRAMID: 81>
| .. grid:: 1
| :margin: 1
|
| .. grid-item::
|
|
|
| Bezier representation of a pyramid with arbitrary order.
|
|
| BEZIER_QUADRILATERAL = <CellType.BEZIER_QUADRILATERAL: 77>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.BezierQuadrilateral
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BezierQuadrilateral-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 4 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Bezier representation of a quadrilateral with arbitrary order.
|
| See also :vtk:`vtkBezierQuadrilateral`.
|
|
| BEZIER_TETRAHEDRON = <CellType.BEZIER_TETRAHEDRON: 78>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.BezierTetrahedron
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BezierTetrahedron-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 6 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 4 <pyvista.CellType.n_faces>`
|
| Bezier representation of a tetrahedron with arbitrary order.
|
| See also :vtk:`vtkBezierTetra`.
|
|
| BEZIER_TRIANGLE = <CellType.BEZIER_TRIANGLE: 76>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.BezierTriangle
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BezierTriangle-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 3 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Bezier representation of a triangle with arbitrary order.
|
| See also :vtk:`vtkBezierTriangle`.
|
|
| BEZIER_WEDGE = <CellType.BEZIER_WEDGE: 80>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.BezierWedge
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BezierWedge-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 9 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>`
|
| Bezier representation of a wedge with arbitrary order.
|
| See also :vtk:`vtkBezierWedge`.
|
|
| BIQUADRATIC_QUAD = <CellType.BIQUADRATIC_QUAD: 28>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.BiQuadraticQuadrilateral
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BiQuadraticQuadrilateral-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 9 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 4 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a 2D, 9-node iso-parametric parabolic quadrilateral element with a center-point.
|
| The cell includes a mid-edge node for each of the four edges of the cell and
| a center node at the surface.
|
| See also :vtk:`vtkBiQuadraticQuad`.
|
|
| BIQUADRATIC_QUADRATIC_HEXAHEDRON = <CellType.BIQUADRATIC_QUADRATIC_HEX...
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.BiQuadraticQuadraticHexahedron
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BiQuadraticQuadraticHexahedron-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 24 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 12 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 6 <pyvista.CellType.n_faces>`
|
| Represents a 3D, 24-node iso-parametric biquadratic hexahedron.
|
| The cell includes mid-edge and center-face nodes.
|
| See also :vtk:`vtkBiQuadraticQuadraticHexahedron`.
|
|
| BIQUADRATIC_QUADRATIC_WEDGE = <CellType.BIQUADRATIC_QUADRATIC_WEDGE: 3...
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.BiQuadraticQuadraticWedge
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BiQuadraticQuadraticWedge-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 18 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 9 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>`
|
| Represents a 3D, 18-node iso-parametric bi-quadratic wedge.
|
| The cell includes a mid-edge node.
|
| See also :vtk:`vtkBiQuadraticQuadraticWedge`.
|
|
| BIQUADRATIC_TRIANGLE = <CellType.BIQUADRATIC_TRIANGLE: 34>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.BiQuadraticTriangle
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-BiQuadraticTriangle-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 7 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 3 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a 2D, 7-node, iso-parametric parabolic triangle.
|
| The cell includes three mid-edge nodes besides the three triangle vertices
| and a center node.
|
| See also :vtk:`vtkBiQuadraticTriangle`.
|
|
| CONVEX_POINT_SET = <CellType.CONVEX_POINT_SET: 41>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.ConvexPointSet
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-ConvexPointSet-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Composite <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: variable <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: variable <pyvista.CellType.n_faces>`
|
| Represents a 3D cell defined by a convex set of points.
|
| See also :vtk:`vtkConvexPointSet`.
|
|
| CUBIC_LINE = <CellType.CUBIC_LINE: 35>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.CubicLine
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-CubicLine-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`1D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 4 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a 1D iso-parametric cubic line.
|
| The cell includes two mid-edge nodes.
|
| See also :vtk:`vtkCubicLine`.
|
|
| EMPTY_CELL = <CellType.EMPTY_CELL: 0>
| .. grid:: 1
| :margin: 1
|
| .. grid-item::
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`0D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 0 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Used as a place-holder during processing.
|
| See also :vtk:`vtkEmptyCell`.
|
|
| HEXAGONAL_PRISM = <CellType.HEXAGONAL_PRISM: 16>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.HexagonalPrism
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-HexagonalPrism-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 12 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 18 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 8 <pyvista.CellType.n_faces>`
|
| Represents a 3D prism with hexagonal base and six quadrilateral faces.
|
| The hexagonal prism is a primary three-dimensional cell defined by an ordered
| list of twelve points.
|
| See also :vtk:`vtkHexagonalPrism`.
|
|
| HEXAHEDRON = <CellType.HEXAHEDRON: 12>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.Hexahedron
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Hexahedron-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 8 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 12 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 6 <pyvista.CellType.n_faces>`
|
| Represents a 3D rectangular hexahedron.
|
| The hexahedron is a primary three-dimensional cell consisting of six
| quadrilateral faces, twelve edges, and eight vertices.
|
| See also :vtk:`vtkHexahedron`.
|
|
| HIGHER_ORDER_EDGE = <CellType.HIGHER_ORDER_EDGE: 60>
|
| HIGHER_ORDER_HEXAHEDRON = <CellType.HIGHER_ORDER_HEXAHEDRON: 67>
|
| HIGHER_ORDER_POLYGON = <CellType.HIGHER_ORDER_POLYGON: 63>
|
| HIGHER_ORDER_PYRAMID = <CellType.HIGHER_ORDER_PYRAMID: 66>
|
| HIGHER_ORDER_QUAD = <CellType.HIGHER_ORDER_QUAD: 62>
|
| HIGHER_ORDER_TETRAHEDRON = <CellType.HIGHER_ORDER_TETRAHEDRON: 64>
|
| HIGHER_ORDER_TRIANGLE = <CellType.HIGHER_ORDER_TRIANGLE: 61>
|
| HIGHER_ORDER_WEDGE = <CellType.HIGHER_ORDER_WEDGE: 65>
|
| LAGRANGE_CURVE = <CellType.LAGRANGE_CURVE: 68>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.LagrangeCurve
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-LagrangeCurve-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`1D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Lagrange representation of a curve with arbitrary order.
|
| See also :vtk:`vtkLagrangeCurve`.
|
|
| LAGRANGE_HEXAHEDRON = <CellType.LAGRANGE_HEXAHEDRON: 72>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.LagrangeHexahedron
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-LagrangeHexahedron-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 12 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 6 <pyvista.CellType.n_faces>`
|
| Lagrange representation of a hexahedron with arbitrary order.
|
| See also :vtk:`vtkLagrangeHexahedron`.
|
|
| LAGRANGE_PYRAMID = <CellType.LAGRANGE_PYRAMID: 74>
| .. grid:: 1
| :margin: 1
|
| .. grid-item::
|
|
|
| Lagrange representation of a pyramid with arbitrary order.
|
|
| LAGRANGE_QUADRILATERAL = <CellType.LAGRANGE_QUADRILATERAL: 70>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.LagrangeQuadrilateral
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-LagrangeQuadrilateral-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 4 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Lagrange representation of a quadrilateral with arbitrary order.
|
| See also :vtk:`vtkLagrangeQuadrilateral`.
|
|
| LAGRANGE_TETRAHEDRON = <CellType.LAGRANGE_TETRAHEDRON: 71>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.LagrangeTetrahedron
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-LagrangeTetrahedron-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 6 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 4 <pyvista.CellType.n_faces>`
|
| Lagrange representation of a tetrahedron with arbitrary order.
|
| See also :vtk:`vtkLagrangeTetra`.
|
|
| LAGRANGE_TRIANGLE = <CellType.LAGRANGE_TRIANGLE: 69>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.LagrangeTriangle
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-LagrangeTriangle-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 3 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Lagrange representation of a triangle with arbitrary order.
|
| See also :vtk:`vtkLagrangeTriangle`.
|
|
| LAGRANGE_WEDGE = <CellType.LAGRANGE_WEDGE: 73>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.LagrangeWedge
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-LagrangeWedge-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 9 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>`
|
| Lagrange representation of a wedge with arbitrary order.
|
| See also :vtk:`vtkLagrangeWedge`.
|
|
| LINE = <CellType.LINE: 3>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.Line
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Line-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`1D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 2 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a 1D line.
|
| The line is a primary one-dimensional cell. It is defined by two points.
| The direction along the line is from the first point to the second point.
|
| See also :vtk:`vtkLine`.
|
|
| PARAMETRIC_CURVE = <CellType.PARAMETRIC_CURVE: 51>
|
| PARAMETRIC_HEX_REGION = <CellType.PARAMETRIC_HEX_REGION: 56>
|
| PARAMETRIC_QUAD_SURFACE = <CellType.PARAMETRIC_QUAD_SURFACE: 54>
|
| PARAMETRIC_SURFACE = <CellType.PARAMETRIC_SURFACE: 52>
|
| PARAMETRIC_TETRA_REGION = <CellType.PARAMETRIC_TETRA_REGION: 55>
|
| PARAMETRIC_TRI_SURFACE = <CellType.PARAMETRIC_TRI_SURFACE: 53>
|
| PENTAGONAL_PRISM = <CellType.PENTAGONAL_PRISM: 15>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.PentagonalPrism
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-PentagonalPrism-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 10 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 15 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 7 <pyvista.CellType.n_faces>`
|
| Represents a convex 3D prism with a pentagonal base and five quadrilateral faces.
|
| The pentagonal prism is a primary three-dimensional cell defined by an ordered
| list of ten points.
|
| See also :vtk:`vtkPentagonalPrism`.
|
|
| PIXEL = <CellType.PIXEL: 8>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.Pixel
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Pixel-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 4 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 4 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a 2D orthogonal quadrilateral.
|
| The pixel is a primary two-dimensional cell defined by an ordered list of four
| points.
|
| .. warning::
| This definition of a pixel differs from the conventional definition which
| describes a single constant-valued element in an image. The meaning of this
| term can vary depending on context. See :ref:`image_representations_example`
| for examples.
|
| See also :vtk:`vtkPixel`.
|
|
| POLYGON = <CellType.POLYGON: 7>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.Polygon
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Polygon-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Composite <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: variable <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a 2D n-sided polygon.
|
| The polygon is a primary two-dimensional cell. It is defined by an ordered list
| of three or more points lying in a plane.
|
| See also :vtk:`vtkPolygon`.
|
|
| POLYHEDRON = <CellType.POLYHEDRON: 42>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.Polyhedron
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Polyhedron-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: variable <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: variable <pyvista.CellType.n_faces>`
|
| Represents a 3D cell defined by a set of polygonal faces.
|
| See also :vtk:`vtkPolyhedron`.
|
|
| POLY_LINE = <CellType.POLY_LINE: 4>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.PolyLine
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-PolyLine-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Composite <pyvista.CellType.is_composite>` :bdg-link-secondary:`1D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a set of 1D lines.
|
| The polyline is a composite one-dimensional cell consisting of one or more
| connected lines.
|
| See also :vtk:`vtkPolyLine`.
|
|
| POLY_VERTEX = <CellType.POLY_VERTEX: 2>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.PolyVertex
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-PolyVertex-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Composite <pyvista.CellType.is_composite>` :bdg-link-secondary:`0D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a set of points in 3D space.
|
| The polyvertex is a composite zero-dimensional cell. It is defined by an
| arbitrarily ordered list of points.
|
| See also :vtk:`vtkPolyVertex`.
|
|
| PYRAMID = <CellType.PYRAMID: 14>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.Pyramid
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Pyramid-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 5 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 8 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>`
|
| Represents a 3D pyramid.
|
| The pyramid is a primary three-dimensional cell consisting of a rectangular base
| with four triangular faces. It is defined by an ordered list of five points.
|
| See also :vtk:`vtkPyramid`.
|
|
| QUAD = <CellType.QUAD: 9>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.Quadrilateral
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Quadrilateral-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 4 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 4 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a 2D quadrilateral.
|
| The quadrilateral is a primary two-dimensional cell. It is defined by an ordered
| list of four points lying in a plane.
|
| See also :vtk:`vtkQuad`.
|
|
| QUADRATIC_EDGE = <CellType.QUADRATIC_EDGE: 21>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.QuadraticEdge
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticEdge-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`1D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 3 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a 1D, 3-node, iso-parametric parabolic line.
|
| The cell includes a mid-edge node.
|
| See also :vtk:`vtkQuadraticEdge`.
|
|
| QUADRATIC_HEXAHEDRON = <CellType.QUADRATIC_HEXAHEDRON: 25>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.QuadraticHexahedron
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticHexahedron-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 20 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 12 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 6 <pyvista.CellType.n_faces>`
|
| Represents a 3D, 20-node iso-parametric parabolic hexahedron.
|
| The cell includes a mid-edge node.
|
| See also :vtk:`vtkQuadraticHexahedron`.
|
|
| QUADRATIC_LINEAR_QUAD = <CellType.QUADRATIC_LINEAR_QUAD: 30>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.QuadraticLinearQuadrilateral
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticLinearQuadrilateral-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 6 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 4 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a 2D, 6-node iso-parametric quadratic-linear quadrilateral element.
|
| The cell includes a mid-edge node for two of the four edges.
|
| See also :vtk:`vtkQuadraticLinearQuad`.
|
|
| QUADRATIC_LINEAR_WEDGE = <CellType.QUADRATIC_LINEAR_WEDGE: 31>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.QuadraticLinearWedge
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticLinearWedge-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 12 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 9 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>`
|
| Represents a 3D, 12-node iso-parametric linear quadratic wedge.
|
| The cell includes mid-edge node in the triangle edges.
|
| See also :vtk:`vtkQuadraticLinearWedge`.
|
|
| QUADRATIC_POLYGON = <CellType.QUADRATIC_POLYGON: 36>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.QuadraticPolygon
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticPolygon-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Composite <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: variable <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a 2D n-sided (2*n nodes) parabolic polygon.
|
| The polygon cannot have any internal holes, and cannot self-intersect.
| The cell includes a mid-edge node for each of the n edges of the cell.
|
| See also :vtk:`vtkQuadraticPolygon`.
|
|
| QUADRATIC_PYRAMID = <CellType.QUADRATIC_PYRAMID: 27>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.QuadraticPyramid
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticPyramid-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 13 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 8 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>`
|
| Represents a 3D, 13-node iso-parametric parabolic pyramid.
|
| The cell includes a mid-edge node.
|
| See also :vtk:`vtkQuadraticPyramid`.
|
|
| QUADRATIC_QUAD = <CellType.QUADRATIC_QUAD: 23>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.QuadraticQuadrilateral
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticQuadrilateral-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 8 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 4 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a 2D, 8-node iso-parametric parabolic quadrilateral element.
|
| The cell includes a mid-edge node for each of the four edges of the cell.
|
| See also :vtk:`vtkQuadraticQuad`.
|
|
| QUADRATIC_TETRA = <CellType.QUADRATIC_TETRA: 24>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.QuadraticTetrahedron
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticTetrahedron-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 10 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 6 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 4 <pyvista.CellType.n_faces>`
|
| Represents a 3D, 10-node, iso-parametric parabolic tetrahedron.
|
| The cell includes a mid-edge node on each of the side edges of the tetrahedron.
|
| See also :vtk:`vtkQuadraticTetra`.
|
|
| QUADRATIC_TRIANGLE = <CellType.QUADRATIC_TRIANGLE: 22>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.QuadraticTriangle
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticTriangle-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 6 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 3 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a 2D, 6-node, iso-parametric parabolic triangle.
|
| The cell includes a mid-edge node for each of the three edges of the cell.
|
| See also :vtk:`vtkQuadraticTriangle`.
|
|
| QUADRATIC_WEDGE = <CellType.QUADRATIC_WEDGE: 26>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.QuadraticWedge
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-QuadraticWedge-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 15 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 9 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>`
|
| Represents a 3D, 15-node iso-parametric parabolic wedge.
|
| The cell includes a mid-edge node.
|
| See also :vtk:`vtkQuadraticWedge`.
|
|
| TETRA = <CellType.TETRA: 10>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.Tetrahedron
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Tetrahedron-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 4 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 6 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 4 <pyvista.CellType.n_faces>`
|
| Represents a 3D tetrahedron.
|
| The tetrahedron is a primary three-dimensional cell. The tetrahedron is defined
| by a list of four non-planar points. It has six edges and four triangular faces.
|
| See also :vtk:`vtkTetra`.
|
|
| TRIANGLE = <CellType.TRIANGLE: 5>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.Triangle
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Triangle-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 3 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 3 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a 2D triangle.
|
| The triangle is a primary two-dimensional cell. The triangle is defined by a
| counter-clockwise ordered list of three points.
|
| See also :vtk:`vtkTriangle`.
|
|
| TRIANGLE_STRIP = <CellType.TRIANGLE_STRIP: 6>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.TriangleStrip
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-TriangleStrip-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Composite <pyvista.CellType.is_composite>` :bdg-link-secondary:`2D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: variable <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: variable <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a 2D triangle strip.
|
| The triangle strip is a composite two-dimensional cell consisting of one or more
| triangles. It is a compact representation of triangles connected edge-to-edge.
|
| See also :vtk:`vtkTriangleStrip`.
|
|
| TRIQUADRATIC_HEXAHEDRON = <CellType.TRIQUADRATIC_HEXAHEDRON: 29>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.TriQuadraticHexahedron
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-TriQuadraticHexahedron-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 27 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 12 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 6 <pyvista.CellType.n_faces>`
|
| Represents a 3D, 27-node iso-parametric triquadratic hexahedron.
|
| The cell includes 8 edge nodes, 12 mid-edge nodes, 6 mid-face nodes and one
| mid-volume node.
|
| See also :vtk:`vtkTriQuadraticHexahedron`.
|
|
| TRIQUADRATIC_PYRAMID = <CellType.TRIQUADRATIC_PYRAMID: 37>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.TriQuadraticPyramid
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-TriQuadraticPyramid-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Non-linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 19 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 8 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>`
|
| Represents a second order 3D iso-parametric 19-node pyramid.
|
| The cell includes 5 corner nodes, 8 mid-edge nodes, 5 mid-face nodes,
| and 1 volumetric centroid node.
|
| See also :vtk:`vtkTriQuadraticPyramid`.
|
|
| VERTEX = <CellType.VERTEX: 1>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.Vertex
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Vertex-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`0D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 1 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 0 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 0 <pyvista.CellType.n_faces>`
|
| Represents a point in 3D space.
|
| The vertex is a primary zero-dimensional cell. It is defined by a single point.
|
| See also :vtk:`vtkVertex`.
|
|
| VOXEL = <CellType.VOXEL: 11>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.Voxel
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Voxel-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 8 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 12 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 6 <pyvista.CellType.n_faces>`
|
| Represents a 3D orthogonal parallelepiped.
|
| The voxel is a primary three-dimensional cell defined by an ordered list of
| eight points.
|
| .. warning::
| This definition of a voxel differs from the conventional definition which
| describes a single constant-valued volume element. The meaning of this
| term can vary depending on context. See :ref:`image_representations_example`
| for examples.
|
| See also :vtk:`vtkVoxel`.
|
|
| WEDGE = <CellType.WEDGE: 13>
| .. grid:: 1 2 2 2
| :reverse:
| :margin: 1
|
| .. grid-item::
| :columns: 12 4 4 4
|
| .. card::
| :class-body: sd-px-0 sd-py-0 sd-rounded-3
| :link: pyvista.examples.cells.Wedge
| :link-type: any
|
| .. image:: /../_build/plot_directive/api/examples/_autosummary/pyvista-examples-cells-Wedge-IMAGE-HASH-PLACEHOLDER_00_00.png
|
| .. grid-item::
| :columns: 12 8 8 8
|
| :bdg-link-primary:`Linear <pyvista.CellType.is_linear>` :bdg-link-success:`Primary <pyvista.CellType.is_composite>` :bdg-link-secondary:`3D <pyvista.CellType.dimension>`
| :bdg-link-muted:`Points: 6 <pyvista.CellType.n_points>` :bdg-link-muted:`Edges: 9 <pyvista.CellType.n_edges>` :bdg-link-muted:`Faces: 5 <pyvista.CellType.n_faces>`
|
| Represents a linear 3D wedge.
|
| The wedge is a primary three-dimensional cell consisting of two triangular
| and three quadrilateral faces.
|
| See also :vtk:`vtkWedge`.
|
|
| ----------------------------------------------------------------------
| Methods inherited from enum.IntEnum:
|
| __repr__(self) from enum.Enum
| Return repr(self).
|
| __str__ = __repr__(self, /) from builtins.int
| Return repr(self).
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.int:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __and__(self, value, /)
| Return self&value.
|
| __bool__(self, /)
| True if self else False
|
| __ceil__(...)
| Ceiling of an Integral returns itself.
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __eq__(self, value, /)
| Return self==value.
|
| __float__(self, /)
| float(self)
|
| __floor__(...)
| Flooring an Integral returns itself.
|
| __floordiv__(self, value, /)
| Return self//value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __index__(self, /)
| Return self converted to an integer, if self is suitable for use as an index into a list.
|
| __int__(self, /)
| int(self)
|
| __invert__(self, /)
| ~self
|
| __le__(self, value, /)
| Return self<=value.
|
| __lshift__(self, value, /)
| Return self<<value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __mod__(self, value, /)
| Return self%value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __neg__(self, /)
| -self
|
| __or__(self, value, /)
| Return self|value.
|
| __pos__(self, /)
| +self
|
| __pow__(self, value, mod=None, /)
| Return pow(self, value, mod).
|
| __radd__(self, value, /)
| Return value+self.
|
| __rand__(self, value, /)
| Return value&self.
|
| __rdivmod__(self, value, /)
| Return divmod(value, self).
|
| __rfloordiv__(self, value, /)
| Return value//self.
|
| __rlshift__(self, value, /)
| Return value<<self.
|
| __rmod__(self, value, /)
| Return value%self.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __ror__(self, value, /)
| Return value|self.
|
| __round__(...)
| Rounding an Integral returns itself.
|
| Rounding with an ndigits argument also returns an integer.
|
| __rpow__(self, value, mod=None, /)
| Return pow(value, self, mod).
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| __rsub__(self, value, /)
| Return value-self.
|
| __rtruediv__(self, value, /)
| Return value/self.
|
| __rxor__(self, value, /)
| Return value^self.
|
| __sizeof__(self, /)
| Returns size in memory, in bytes.
|
| __sub__(self, value, /)
| Return self-value.
|
| __truediv__(self, value, /)
| Return self/value.
|
| __trunc__(...)
| Truncating an Integral returns itself.
|
| __xor__(self, value, /)
| Return self^value.
|
| as_integer_ratio(self, /)
| Return a pair of integers, whose ratio is equal to the original int.
|
| The ratio is in lowest terms and has a positive denominator.
|
| >>> (10).as_integer_ratio()
| (10, 1)
| >>> (-10).as_integer_ratio()
| (-10, 1)
| >>> (0).as_integer_ratio()
| (0, 1)
|
| bit_count(self, /)
| Number of ones in the binary representation of the absolute value of self.
|
| Also known as the population count.
|
| >>> bin(13)
| '0b1101'
| >>> (13).bit_count()
| 3
|
| bit_length(self, /)
| Number of bits necessary to represent self in binary.
|
| >>> bin(37)
| '0b100101'
| >>> (37).bit_length()
| 6
|
| conjugate(...)
| Returns self, the complex conjugate of any int.
|
| is_integer(self, /)
| Returns True. Exists for duck type compatibility with float.is_integer.
|
| to_bytes(self, /, length=1, byteorder='big', *, signed=False)
| Return an array of bytes representing an integer.
|
| length
| Length of bytes object to use. An OverflowError is raised if the
| integer is not representable with the given number of bytes. Default
| is length 1.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| `sys.byteorder' as the byte order value. Default is to use 'big'.
| signed
| Determines whether two's complement is used to represent the integer.
| If signed is False and a negative integer is given, an OverflowError
| is raised.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.int:
|
| from_bytes(bytes, byteorder='big', *, signed=False)
| Return the integer represented by the given array of bytes.
|
| bytes
| Holds the array of bytes to convert. The argument must either
| support the buffer protocol or be an iterable object producing bytes.
| Bytes and bytearray are examples of built-in objects that support the
| buffer protocol.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| `sys.byteorder' as the byte order value. Default is to use 'big'.
| signed
| Indicates whether two's complement is used to represent the integer.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.int:
|
| denominator
| the denominator of a rational number in lowest terms
|
| imag
| the imaginary part of a complex number
|
| numerator
| the numerator of a rational number in lowest terms
|
| real
| the real part of a complex number
|
| ----------------------------------------------------------------------
| Methods inherited from enum.Enum:
|
| __dir__(self)
| Returns public methods and other interesting attributes.
|
| __init__(self, *args, **kwds)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce_ex__(self, proto)
| Helper for pickle.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from enum.Enum:
|
| name
| The name of the Enum member.
|
| value
| The value of the Enum member.
|
| ----------------------------------------------------------------------
| Static methods inherited from enum.EnumType:
|
| __contains__(value)
| Return True if `value` is in `cls`.
|
| `value` is in `cls` if:
| 1) `value` is a member of `cls`, or
| 2) `value` is the value of one of the `cls`'s members.
|
| __getitem__(name)
| Return the member matching `name`.
|
| __iter__()
| Return members in definition order.
|
| __len__()
| Return the number of members (no aliases)
|
| ----------------------------------------------------------------------
| Readonly properties inherited from enum.EnumType:
|
| __members__
| Returns a mapping of member name->value.
|
| This mapping lists all enum members, including aliases. Note that this
| is a read-only view of the internal mapping.
DATA
ClassVar = typing.ClassVar
Special type construct to mark class variables.
An annotation wrapped in ClassVar indicates that a given
attribute is intended to be used as a class variable and
should not be set on instances of that class.
Usage::
class Starship:
stats: ClassVar[dict[str, int]] = {} # class variable
damage: int = 10 # instance variable
ClassVar accepts only types and cannot be further subscribed.
Note that ClassVar is not a class itself, and should not
be used with isinstance() or issubclass().
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
PLACEHOLDER = 'IMAGE-HASH-PLACEHOLDER'
__annotations__ = {'_ABSTRACT_DIMENSIONS': 'dict[int, _Dimension]'}
vtk_version_info = VTKVersionInfo(major=9, minor=6, micro=2)
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\celltype.py
pyvista.check_math_text_support
Python Library Documentation: function check_math_text_support in module pyvista.report
check_math_text_support() -> 'bool'
Check if MathText and LaTeX symbols are supported.
Returns
-------
bool
``True`` if both MathText and LaTeX symbols are supported, ``False``
otherwise.
pyvista.check_matplotlib_vtk_compatibility
Python Library Documentation: function check_matplotlib_vtk_compatibility in module pyvista.report
check_matplotlib_vtk_compatibility() -> 'bool'
Check if VTK and Matplotlib versions are compatible for MathText rendering.
This function is primarily geared towards checking if MathText rendering is
supported with the given versions of VTK and Matplotlib. It follows the
version constraints:
* VTK <= 9.2.2 requires Matplotlib < 3.6
* VTK > 9.2.2 requires Matplotlib >= 3.6
Other version combinations of VTK and Matplotlib will work without
errors, but some features (like MathText/LaTeX rendering) may
silently fail.
Returns
-------
bool
True if the versions of VTK and Matplotlib are compatible for MathText
rendering, False otherwise.
Raises
------
RuntimeError
If the versions of VTK and Matplotlib cannot be checked.
pyvista.check_valid_vector
Python Library Documentation: function check_valid_vector in module pyvista.core.utilities.misc
check_valid_vector(point: 'VectorLike[float]', name: 'str' = '') -> 'None'
Check if a vector contains three components.
Parameters
----------
point : VectorLike[float]
Input vector to check. Must be an iterable with exactly three components.
name : str, optional
Name to use in the error messages. If not provided, "Vector" will be used.
Raises
------
TypeError
If the input is not an iterable.
ValueError
If the input does not have exactly three components.
pyvista.composite
Python Library Documentation: module pyvista.core.composite in pyvista.core
NAME
pyvista.core.composite - Container to mimic :vtk:`vtkMultiBlockDataSet` objects.
DESCRIPTION
These classes hold many VTK datasets in one object that can be passed
to VTK algorithms and PyVista filtering/plotting routines.
CLASSES
collections.abc.MutableSequence(collections.abc.Sequence)
MultiBlock(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.filters.composite.CompositeFilters, pyvista.core.dataobject.DataObject, collections.abc.MutableSequence, vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet)
pyvista.core.dataobject.DataObject(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride)
MultiBlock(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.filters.composite.CompositeFilters, pyvista.core.dataobject.DataObject, collections.abc.MutableSequence, vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet)
pyvista.core.filters.composite.CompositeFilters(pyvista.core.filters.data_object.DataObjectFilters)
MultiBlock(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.filters.composite.CompositeFilters, pyvista.core.dataobject.DataObject, collections.abc.MutableSequence, vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet)
pyvista.core.utilities.misc._BoundsSizeMixin(builtins.object)
MultiBlock(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.filters.composite.CompositeFilters, pyvista.core.dataobject.DataObject, collections.abc.MutableSequence, vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet)
vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet(vtkmodules.vtkCommonDataModel.vtkDataObjectTree)
MultiBlock(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.filters.composite.CompositeFilters, pyvista.core.dataobject.DataObject, collections.abc.MutableSequence, vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet)
class MultiBlock(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.filters.composite.CompositeFilters, pyvista.core.dataobject.DataObject, collections.abc.MutableSequence, vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet)
| MultiBlock(*args, **kwargs) -> '_T'
|
| A composite class to hold many data sets which can be iterated over.
|
| This wraps/extends the :vtk:`vtkMultiBlockDataSet` class
| so that we can easily plot these data sets and use the composite in a
| Pythonic manner.
|
| You can think of ``MultiBlock`` like a list as we
| can iterate over this data structure by index. It has some dictionary
| features as we can also access blocks by their string name.
|
| .. versionchanged:: 0.36.0
| ``MultiBlock`` adheres more closely to being list like, and inherits
| from :class:`collections.abc.MutableSequence`. Multiple nonconforming
| behaviors were removed or modified.
|
| Parameters
| ----------
| *args : dict, optional
| Data object dictionary.
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| **kwargs : dict, optional
| See :func:`pyvista.read` for additional options.
|
| Examples
| --------
| >>> import pyvista as pv
|
| Create an empty composite dataset.
|
| >>> blocks = pv.MultiBlock()
|
| Add a dataset to the collection.
|
| >>> sphere = pv.Sphere()
| >>> blocks.append(sphere)
|
| Add a named block.
|
| >>> blocks['cube'] = pv.Cube()
|
| Instantiate from a list of objects.
|
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.plot()
|
| Instantiate from a dictionary.
|
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.plot()
|
| Iterate over the collection.
|
| >>> for name in blocks.keys():
| ... block = blocks[name]
|
| >>> for block in blocks:
| ... # Do something with each dataset
| ... surf = block.extract_surface(algorithm=None)
|
| Method resolution order:
| MultiBlock
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.composite.CompositeFilters
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| collections.abc.MutableSequence
| collections.abc.Sequence
| collections.abc.Reversible
| collections.abc.Collection
| collections.abc.Sized
| collections.abc.Iterable
| collections.abc.Container
| vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObjectTree
| vtkmodules.vtkCommonDataModel.vtkCompositeDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __delitem__(self: 'MultiBlock', index: 'int | str | slice') -> 'None'
| Remove a block at the specified index.
|
| __eq__(self: 'MultiBlock', other: 'object') -> 'bool'
| Equality comparison.
|
| __getitem__(self: 'MultiBlock', index)
| Get a block by its index or name.
|
| If the name is non-unique then returns the first occurrence.
|
| __init__(self: 'MultiBlock', *args, validate: 'bool | _NestedMeshValidationFields' = False, **kwargs) -> 'None'
| Initialize multi block.
|
| __len__(self: 'MultiBlock') -> 'int'
| Return the number of blocks.
|
| __repr__(self: 'MultiBlock') -> 'str'
| Define an adequate representation.
|
| __setitem__(self: 'MultiBlock', index: 'int | str | slice', data) -> 'None'
| Set a block with a VTK data object.
|
| To set the name simultaneously, pass a string name as the 2nd index.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> multi = pv.MultiBlock()
| >>> multi.append(pv.PolyData())
| >>> multi[0] = pv.UnstructuredGrid()
| >>> multi.append(pv.PolyData(), 'poly')
| >>> multi.keys()
| ['Block-00', 'poly']
| >>> multi['bar'] = pv.PolyData()
| >>> multi.n_blocks
| 3
|
| __str__(self: 'MultiBlock') -> 'str'
| Return the str representation of the multi block.
|
| append(self: 'MultiBlock', dataset: '_TypeMultiBlockLeaf', name: 'str | None' = None) -> 'None'
| Add a data set to the next block index.
|
| Parameters
| ----------
| dataset : pyvista.DataSet or pyvista.MultiBlock
| Dataset to append to this multi-block.
|
| name : str, optional
| Block name to give to dataset. A default name is given
| depending on the block index as ``'Block-{i:02}'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.append(pv.Cone())
| >>> len(blocks)
| 3
| >>> blocks.append(examples.load_uniform(), 'uniform')
| >>> blocks.keys()
| ['cube', 'sphere', 'Block-02', 'uniform']
|
| as_polydata_blocks(self: 'MultiBlock', copy: 'bool' = False) -> 'MultiBlock'
| Convert all the datasets within this MultiBlock to :class:`~pyvista.PolyData`.
|
| Parameters
| ----------
| copy : bool, default: False
| Option to create a shallow copy of any datasets that are already a
| :class:`~pyvista.PolyData`. When ``False``, any datasets that are
| already PolyData will not be copied.
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock containing only :class:`pyvista.PolyData` datasets.
|
| See Also
| --------
| as_unstructured_grid_blocks
| Convert all blocks to :class:`~pyvista.UnstructuredGrid`.
| is_all_polydata
| Check if all blocks are :class:`~pyvista.PolyData`.
| :meth:`~pyvista.DataObjectFilters.extract_surface`
| Convert this :class:`~pyvista.MultiBlock` to :class:`~pyvista.PolyData`.
|
| Notes
| -----
| Null blocks are converted to empty :class:`pyvista.PolyData`
| objects. Downstream filters that operate on PolyData cannot accept
| MultiBlocks with null blocks.
|
| as_unstructured_grid_blocks(self: 'MultiBlock', copy: 'bool' = False) -> 'MultiBlock'
| Convert all the datasets within this MultiBlock to :class:`~pyvista.UnstructuredGrid`.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| copy : bool, default: False
| Option to create a shallow copy of any datasets that are already a
| :class:`~pyvista.UnstructuredGrid`. When ``False``, any datasets that are
| already UnstructuredGrid will not be copied.
|
| Returns
| -------
| MultiBlock
| MultiBlock containing only :class:`~pyvista.UnstructuredGrid` datasets.
|
| See Also
| --------
| as_polydata_blocks
|
| Notes
| -----
| Null blocks are converted to empty :class:`~pyvista.UnstructuredGrid`
| objects. Downstream filters that operate on UnstructuredGrid may not accept
| MultiBlocks with null blocks.
|
| clean(self: 'MultiBlock', empty: 'bool' = True) -> 'None'
| Remove any null blocks in place.
|
| Parameters
| ----------
| empty : bool, default: True
| Remove any meshes that are empty as well (have zero points).
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = {'cube': pv.Cube(), 'empty': pv.PolyData()}
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.clean(empty=True)
| >>> blocks.keys()
| ['cube']
|
| clear_all_cell_data(self: 'MultiBlock') -> 'None'
| Clear all cell data from all blocks.
|
| clear_all_data(self: 'MultiBlock') -> 'None'
| Clear all data from all blocks.
|
| clear_all_point_data(self: 'MultiBlock') -> 'None'
| Clear all point data from all blocks.
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the multiblock.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True``, make a full copy of the object.
|
| Returns
| -------
| pyvista.MultiBlock
| Deep or shallow copy of the ``MultiBlock``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> blocks = pv.MultiBlock(data)
| >>> new_blocks = blocks.copy()
| >>> len(new_blocks)
| 3
|
| copy_meta_from(self: 'MultiBlock', ido: 'MultiBlock', deep: 'bool') -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| deep_copy(self: 'MultiBlock', to_copy: '_vtk.vtkMultiBlockDataSet') -> 'None'
| Overwrite this MultiBlock with another MultiBlock as a deep copy.
|
| Parameters
| ----------
| to_copy : MultiBlock | :vtk:`vtkMultiBlockDataSet`
| MultiBlock to perform a deep copy from.
|
| extend(self: 'MultiBlock', datasets: 'Iterable[_TypeMultiBlockLeaf]') -> 'None'
| Extend MultiBlock with an Iterable.
|
| If another MultiBlock object is supplied, the key names will
| be preserved.
|
| Parameters
| ----------
| datasets : Iterable[pyvista.DataSet or pyvista.MultiBlock]
| Datasets to extend.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks_uniform = pv.MultiBlock({'uniform': examples.load_uniform()})
| >>> blocks.extend(blocks_uniform)
| >>> len(blocks)
| 3
| >>> blocks.keys()
| ['cube', 'sphere', 'uniform']
|
| flatten(self, *, order: "Literal['nested_first', 'nested_last'] | None" = None, name_mode: "Literal['preserve', 'prepend', 'reset']" = 'preserve', field_data_mode: "Literal['preserve', 'prepend']" = 'preserve', user_dict_mode: "Literal['preserve', 'prepend', 'flat', 'nested']" = 'preserve', separator: 'str' = '::', check_duplicate_keys: 'bool' = True, copy: 'bool' = True) -> 'MultiBlock'
| Flatten this :class:`MultiBlock`.
|
| Recursively iterate through all blocks and store them in a single
| :class:`MultiBlock` instance. All nested :class:`~pyvista.DataSet` and ``None``
| blocks are preserved, and any nested ``MultiBlock`` container blocks are removed.
| Field data from any nested ``MultiBlock`` containers is preserved, however, and
| is also flattened.
|
| The flattening operation is "safe" by default in the sense that duplicate keys
| for block names and field data are not allowed and no data will be overwritten.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| order : 'nested_last', 'nested_first', optional
| Order in which to flatten the contents.
|
| - ``'nested_first'``: Flatten nested ``MultiBlock`` blocks first.
| - ``'nested_last'``: Flatten nested ``MultiBlock`` blocks last.
|
| By default, the ``MultiBlock`` is flattened recursively as-is without
| changing the order.
|
| name_mode : 'preserve' | 'prepend' | 'reset', default: 'preserve'
| Mode for naming blocks in the flattened output.
|
| - ``'preserve'``: The names of all blocks are preserved.
| - ``'prepend'``: Preserve the block names and prepend the parent names.
| - ``'reset'``: Reset the block names to default values.
|
| field_data_mode : 'preserve' | 'prepend', default: 'preserve'
| Mode for naming the root field data keys when flattening nested field data.
|
| - ``'preserve'``: The array names of nested field data are preserved.
| - ``'prepend'``: Preserve the array names and prepend the parent names.
|
| user_dict_mode : 'preserve' | 'prepend' | 'flat' | 'nested', default: 'preserve'
| Mode for naming the flattened :attr:`~pyvista.DataObject.user_dict` keys when
| nested :class:`MultiBlock` blocks define a user-dict.
|
| - ``'preserve'``: Update the flattened user dict directly with the items of
| any nested user-dict.
| - ``'nested'``: Create nested keys in the flattened user-dict which match
| the nested hierarchy of any nested ``MultiBlock`` blocks.
| - ``'flat'``: Create a new key in the flattened user dict for each nested
| ``MultiBlock`` that has a user-dict.
| - ``'prepend'``: Similar to ``'flat'`` except the key names are prepended
| with the parent block names.
|
| .. note::
| If there is only a single level of nesting the ``'flat'``, ``'nested'``
| and ``'prepend'`` modes are all equivalent. They only differ when there
| is at least two levels of nesting.
|
| separator : str, default: '::'
| String separator to use when ``'prepend'`` mode is used. The separator
| is inserted between parent and child block name or field data array names.
|
| check_duplicate_keys : bool, default: True
| Flatten the MultiBlock data safely without overwriting any data or
| duplicating block names. If ``True``, an error is raised if any duplicate,
| non-unique field data keys or block names are identified. If ``False``,
| nested field data is flattened without checking for duplicate keys and data
| may be overwritten; the flattened MultiBlock may also have duplicate block
| names.
|
| copy : bool, default: True
| Return a deep copy of all nested blocks in the flattened ``MultiBlock``.
| If ``False``, shallow copies are returned.
|
| Returns
| -------
| MultiBlock
| Flattened ``MultiBlock``.
|
| See Also
| --------
| recursive_iterator
| move_nested_field_data_to_root
| pyvista.CompositeFilters.generic_filter
| clean
|
| Examples
| --------
| Create a nested :class:`MultiBlock` with three levels of nesting and
| three end nodes.
|
| >>> import pyvista as pv
| >>> nested = pv.MultiBlock(
| ... {
| ... 'nested1': pv.MultiBlock(
| ... {
| ... 'nested2': pv.MultiBlock({'poly': pv.PolyData()}),
| ... 'image': pv.ImageData(),
| ... }
| ... ),
| ... 'none': None,
| ... }
| ... )
|
| The root ``MultiBlock`` has two blocks.
|
| >>> nested.n_blocks
| 2
|
| >>> type(nested[0]), type(nested[1])
| (<class 'pyvista.core.composite.MultiBlock'>, <class 'NoneType'>)
|
| Flatten the ``MultiBlock``. The nested ``MultiBlock`` containers are removed
| and only their contents are returned (i.e. the three end nodes).
|
| >>> flat = nested.flatten()
| >>> flat.n_blocks
| 3
|
| >>> (
| ... type(flat[0]),
| ... type(flat[1]),
| ... type(flat[2]),
| ... ) # doctest: +NORMALIZE_WHITESPACE
| (<class 'pyvista.core.pointset.PolyData'>,
| <class 'pyvista.core.grid.ImageData'>,
| <class 'NoneType'>)
|
| By default, the block names are preserved.
|
| >>> flat.keys()
| ['poly', 'image', 'none']
|
| Prepend the names of parent blocks to the names instead.
|
| >>> flat = nested.flatten(name_mode='prepend')
| >>> flat.keys()
| ['nested1::nested2::poly', 'nested1::image', 'none']
|
| Reset the names to default values instead.
|
| >>> flat = nested.flatten(name_mode='reset')
| >>> flat.keys()
| ['Block-00', 'Block-01', 'Block-02']
|
| Flatten the ``MultiBlock`` with nested multi-blocks flattened last. Note the difference
| between this ordering of blocks and the default ordering returned earlier.
|
| >>> flat = nested.flatten(order='nested_last')
| >>> (
| ... type(flat[0]),
| ... type(flat[1]),
| ... type(flat[2]),
| ... ) # doctest: +NORMALIZE_WHITESPACE
| (<class 'NoneType'>,
| <class 'pyvista.core.grid.ImageData'>,
| <class 'pyvista.core.pointset.PolyData'>)
|
| get(self: 'MultiBlock', index: 'int | str', default: '_TypeMultiBlockLeaf' = None) -> '_TypeMultiBlockLeaf'
| Get a block by its index or name.
|
| If the name is non-unique then returns the first occurrence.
| Returns ``default`` if name isn't in the dataset.
|
| Parameters
| ----------
| index : int | str
| Index or name of the dataset within the multiblock.
|
| default : pyvista.DataSet or pyvista.MultiBlock, optional
| Default to return if index is not in the multiblock.
|
| Returns
| -------
| output : pyvista.DataSet | pyvista.MultiBlock | None
| Dataset from the given index if it exists.
|
| See Also
| --------
| get_block
| Get a block and raise an ``IndexError`` if index is not found.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> data = {'poly': pv.PolyData(), 'img': pv.ImageData()}
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.get('poly')
| PolyData ...
| >>> blocks.get('cone')
|
| get_block(self: 'MultiBlock', index: 'int | Sequence[int] | str') -> '_TypeMultiBlockLeaf'
| Get a block by its index or name.
|
| If the name is non-unique then returns the first occurrence. This
| method is similar to using ``[]`` for indexing except this method also
| supports indexing nested blocks.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| index : int | Sequence[int] | str
| Index or name of the dataset within the multiblock. Specify a sequence of
| indices to replace a nested block.
|
| Returns
| -------
| output : pyvista.DataSet | pyvista.MultiBlock | None
| Dataset from the given index if it exists.
|
| See Also
| --------
| get
| Get a block and return a default value instead of raising an ``IndexError``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> blocks = pv.MultiBlock([pv.PolyData(), pv.ImageData()])
| >>> nested = pv.MultiBlock([blocks])
|
| >>> nested.get_block(0)
| MultiBlock ...
| >>> nested.get_block((0, 1))
| ImageData ...
|
| get_block_name(self: 'MultiBlock', index: 'int') -> 'str'
| Return the string name of the block at the given index.
|
| Parameters
| ----------
| index : int
| Index of the block to get the name of.
|
| Returns
| -------
| str
| Name of the block at the given index.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.get_block_name(0)
| 'cube'
|
| get_data_range(self: 'MultiBlock', name: 'str | None', allow_missing: 'bool' = False, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min/max of an array given its name across all blocks.
|
| Parameters
| ----------
| name : str, optional
| The name of the array to get the range. If ``None``, the
| active scalars are used.
|
| allow_missing : bool, default: False
| Allow a block to be missing the named array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| .. versionadded:: 0.45
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| get_index_by_name(self: 'MultiBlock', name: 'str') -> 'int'
| Find the index number by block name.
|
| Parameters
| ----------
| name : str
| Name of the block.
|
| Returns
| -------
| int
| Index of the block.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.get_index_by_name('sphere')
| 1
|
| insert(self: 'MultiBlock', index: 'int', dataset: '_TypeMultiBlockLeaf', name: 'str | None' = None) -> 'None'
| Insert data before index.
|
| Parameters
| ----------
| index : int
| Index before which to insert data.
| dataset : pyvista.DataSet or pyvista.MultiBlock
| Data to insert.
| name : str, optional
| Name for key to give dataset. A default name is given
| depending on the block index as ``'Block-{i:02}'``.
|
| Examples
| --------
| Insert a new :class:`pyvista.PolyData` at the start of the multiblock.
|
| >>> import pyvista as pv
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.keys()
| ['cube', 'sphere']
| >>> blocks.insert(0, pv.Plane(), 'plane')
| >>> blocks.keys()
| ['plane', 'cube', 'sphere']
|
| keys(self: 'MultiBlock') -> 'list[str]'
| Get all the block names in the dataset.
|
| Returns
| -------
| list
| List of block names.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.keys()
| ['cube', 'sphere']
|
| move_nested_field_data_to_root(self, *, copy: 'bool | None' = None, field_data_mode: "Literal['preserve', 'prepend']" = 'preserve', user_dict_mode: "Literal['preserve', 'prepend', 'flat', 'nested']" = 'preserve', separator: 'str' = '::', check_duplicate_keys: 'bool' = True) -> 'None'
| Move or copy field data from all nested :class:`MultiBlock` blocks.
|
| Any nested :class:`MultiBlock` blocks will have its :attr:`~pyvista.DataObject.field_data`
| contents moved to the root block, (i.e. `this` ``MultiBock``). By default, this
| data will be cleared from the nested block(s) but a copy may be made instead.
|
| If any nested :class:`MultiBlock` blocks define a :attr:`~pyvista.DataObject.user_dict`,
| the root user-dict is also updated to include the nested block's user-dict
| data.
|
| All field data and user-dict keys are directly updated from the nested blocks
| by default. Optionally, different modes are provided to control the key names
| and/or how the data is moved. The move is done safely such that no key values
| will be overwritten and no data is lost. If any nested keys are duplicates
| of the root keys, an error is raised.
|
| .. note::
| This operation only applies to nested :class:`MultiBlock` blocks. Field data
| associated with :class:`~pyvista.DataSet` blocks is `not` affected.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| copy : bool, optional
| Set this value to copy the data. If ``True``, deep-copy the data from nested
| ``MultiBlock`` blocks to the root block. Both the root and nested blocks
| will share the same keys and refer to separate copies of the data. If
| ``False``, both the root and nested blocks will share the same keys but
| refer to the same data. By default, no copy is made; the nested field data
| is moved to the root block and cleared from the nested ``MultiBlock`` blocks.
|
| .. note::
|
| This option does not apply to any nested :attr:`~pyvista.DataObject.user_dict`
| data. User-dict data is always deep-copied.
|
| field_data_mode : 'preserve' | 'prepend', default: 'preserve'
| Mode for naming the root field data keys when moving nested field data.
|
| - ``'preserve'``: The array names of nested field data are preserved.
| - ``'prepend'``: Preserve the array names and prepend the parent names.
|
| user_dict_mode : 'preserve' | 'prepend' | 'flat' | 'nested', default: 'preserve'
| Mode for naming the root :attr:`~pyvista.DataObject.user_dict` keys when
| nested :class:`MultiBlock` blocks define a user-dict.
|
| - ``'preserve'``: Update the root user dict directly with the items of any
| nested user-dict.
| - ``'nested'``: Create nested keys in the root user-dict which match the
| nested hierarchy of any nested ``MultiBlock`` blocks.
| - ``'flat'``: Create a new key in the root user dict for each nested
| ``MultiBlock`` that has a user-dict.
| - ``'prepend'``: Similar to ``'flat'`` except the key names are prepended
| with the parent block names.
|
| .. note::
| If there is only a single level of nesting the ``'flat'``, ``'nested'``
| and ``'prepend'`` modes are all equivalent. They only differ when there
| is at least two levels of nesting.
|
| separator : str, default: '::'
| String separator to use when ``'prepend'`` mode is enabled for either field
| data or for the user-dict. The separator is inserted between parent and child
| block names.
|
| check_duplicate_keys : bool, default: True
| Update the root data safely without overwriting existing data. If ``True``,
| an error is raised if any nested keys match the root block's keys. If
| ``False``, nested data is moved without checking if a key already exists,
| and data may be overwritten.
|
| Raises
| ------
| ValueError
| If any field data keys in nested :class:`MultiBlock` blocks are duplicated
| in the root block and ``check_duplicate_keys`` is ``True``.
|
| See Also
| --------
| flatten
|
| Examples
| --------
| Create a :class:`MultiBlock` with field data.
|
| >>> import pyvista as pv
| >>> multi = pv.MultiBlock()
| >>> multi.field_data['data'] = [1, 2, 3]
|
| Nest the dataset inside another ``MultiBlock``.
|
| >>> root = pv.MultiBlock([multi])
|
| Show that the root block does not have any field data.
|
| >>> root.field_data.keys()
| []
|
| Move the nested field data to the root.
|
| >>> root.move_nested_field_data_to_root()
|
| The field data is now at the root.
|
| >>> root.field_data.keys()
| ['data']
|
| And no longer exists in the nested ``MultiBlock``.
|
| >>> multi.field_data.keys()
| []
|
| Add more field data to the nested block.
|
| >>> multi.field_data['more_data'] = [4, 5, 6]
|
| Move it to the root again, but this time prepend the name of the block the data
| came from.
|
| >>> root.move_nested_field_data_to_root(field_data_mode='prepend')
| >>> root.field_data.keys()
| ['data', 'Block-00::more_data']
|
| The :attr:`~pyvista.DataObject.user_dict` is also field data which is moved to
| the root block's user-dict.
|
| Add sample data to the nested block and move it to the root.
|
| >>> data = dict(foo='bar')
| >>> multi.user_dict = data
| >>> root.move_nested_field_data_to_root()
|
| Check the root's user-dict. By default, the key names are preserved and the root
| dict is updated with the nested dict.
|
| >>> root.user_dict
| {"foo": "bar"}
|
| Clear the field data and re-add data to the nested user-dict.
|
| >>> root.clear_field_data()
| >>> multi.user_dict = data
|
| Move the data again but use the ``'flat'`` mode. This time, a new key is added
| which matches the nested block's name.
|
| >>> root.move_nested_field_data_to_root(user_dict_mode='flat')
| >>> root.user_dict
| {"Block-00": {"foo": "bar"}}
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| pop(self: 'MultiBlock', index: 'int | str' = -1) -> '_TypeMultiBlockLeaf'
| Pop off a block at the specified index.
|
| Parameters
| ----------
| index : int or str, default: -1
| Index or name of the dataset within the multiblock. Defaults to
| last dataset.
|
| Returns
| -------
| output : pyvista.DataSet | pyvista.MultiBlock
| Dataset from the given index that was removed.
|
| Examples
| --------
| Pop the ``"cube"`` multiblock.
|
| >>> import pyvista as pv
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.keys()
| ['cube', 'sphere']
| >>> cube = blocks.pop('cube')
| >>> blocks.keys()
| ['sphere']
|
| recursive_iterator(self: 'MultiBlock', contents: "Literal['ids', 'names', 'blocks', 'items', 'all']" = 'blocks', order: "Literal['nested_first', 'nested_last'] | None" = None, *, node_type: "Literal['parent', 'child']" = 'child', skip_none: 'bool' = False, skip_empty: 'bool' = False, nested_ids: 'bool | None' = None, prepend_names: 'bool' = False, separator: 'str' = '::') -> 'Iterator[int | tuple[int, ...] | str | _TypeMultiBlockLeaf] | Iterator[tuple[str, _TypeMultiBlockLeaf]] | Iterator[tuple[int | tuple[int, ...], str, _TypeMultiBlockLeaf]]'
| Iterate over all nested blocks recursively.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| contents : 'ids' | 'names' | 'blocks' | 'items', default: 'blocks'
| Values to include in the iterator.
|
| - ``'ids'``: Return an iterator with nested block indices.
| - ``'names'``: Return an iterator with nested block names (i.e. :meth:`keys`).
| - ``'blocks'``: Return an iterator with nested blocks.
| - ``'items'``: Return an iterator with nested ``(name, block)`` pairs.
| - ``'all'``: Return an iterator with nested ``(index, name, block)`` triplets.
|
| .. note::
|
| Use the ``nested_ids`` and ``prepend_names`` options to modify how
| the block ids and names are represented, respectively.
|
| order : 'nested_first', 'nested_last', optional
| Order in which to iterate through nested blocks.
|
| - ``'nested_first'``: Iterate through nested ``MultiBlock`` blocks first.
| - ``'nested_last'``: Iterate through nested ``MultiBlock`` blocks last.
|
| By default, the ``MultiBlock`` is iterated recursively as-is without
| changing the order. This option only applies when ``node_type`` is ``'child'``.
|
| node_type : 'parent' | 'child', default: 'child'
| Type of node blocks to generate ``contents`` from. If ``'parent'``, the
| contents are generated from :class:`MultiBlock` nodes. If ``'child'``, the
| contents are generated from :class:`~pyvista.DataSet` and ``None`` nodes.
|
| skip_none : bool, default: False
| If ``True``, do not include ``None`` blocks in the iterator. This option
| only applies when ``node_type`` is ``'child'``.
|
| skip_empty : bool, default: False
| If ``True``, do not include empty meshes in the iterator. If ``node_type``
| is ``'parent'``, any :class:`MultiBlock` block with length ``0`` is skipped.
| If ``node_type`` is ``'child'``, any :class:`~pyvista.DataSet` block with
| ``0`` points is skipped.
|
| nested_ids : bool, default: True
| Prepend parent block indices to the child block indices. If ``True``, a
| tuple of indices is returned for each block. If ``False``, a single integer
| index is returned for each block. This option only applies when ``contents``
| is ``'ids'`` or ``'all'``.
|
| prepend_names : bool, default: False
| Prepend any parent block names to the child block names. This option
| only applies when ``contents`` is ``'names'``, ``'items'``, or ``'all'``.
|
| separator : str, default: '::'
| String separator to use when ``prepend_names`` is enabled. The separator
| is inserted between parent and child block names.
|
| Returns
| -------
| Iterator
| Iterator of ids, names, blocks, or name-block pairs depending on ``contents``.
|
| See Also
| --------
| flatten
| Uses the iterator internally to flatten a :class:`MultiBlock`.
| pyvista.CompositeFilters.generic_filter
| Uses the iterator internally to apply filters to all blocks.
| clean
| Remove ``None`` and/or empty mesh blocks.
|
| Examples
| --------
| Load a :class:`MultiBlock` with nested datasets.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> multi = examples.download_exodus()
|
| The dataset has eight :class:`MultiBlock` blocks.
|
| >>> multi.n_blocks
| 8
|
| >>> all(isinstance(block, pv.MultiBlock) for block in multi)
| True
|
| Get the iterator and show the count of all recursively nested blocks.
|
| >>> iterator = multi.recursive_iterator()
| >>> iterator
| <generator object MultiBlock._recursive_iterator at ...>
|
| >>> len(list(iterator))
| 11
|
| Check if all blocks are :class:`~pyvista.DataSet` objects. Note that ``None``
| blocks are included by default, so this may not be ``True`` in all cases.
|
| >>> all(isinstance(item, pv.DataSet) for item in multi.recursive_iterator())
| True
|
| Use the iterator to apply a filter inplace to all recursively nested datasets.
|
| >>> _ = [
| ... dataset.connectivity(inplace=True)
| ... for dataset in multi.recursive_iterator()
| ... ]
|
| Iterate through nested block names.
|
| >>> iterator = multi.recursive_iterator('names')
| >>> next(iterator)
| 'Unnamed block ID: 1'
|
| Prepend parent block names.
|
| >>> iterator = multi.recursive_iterator('names', prepend_names=True)
| >>> next(iterator)
| 'Element Blocks::Unnamed block ID: 1'
|
| Iterate through name-block pairs. Prepend parent block names again using a
| custom separator.
|
| >>> iterator = multi.recursive_iterator(
| ... 'items', prepend_names=True, separator='->'
| ... )
| >>> next(iterator)
| ('Element Blocks->Unnamed block ID: 1', UnstructuredGrid (...)
| N Cells: 336
| N Points: 400
| X Bounds: 0.000e+00, 1.200e+01
| Y Bounds: 0.000e+00, 3.500e+00
| Z Bounds: 0.000e+00, 3.399e+00
| N Arrays: 6)
|
| Iterate through ids. The ids are returned as a tuple by default.
|
| >>> iterator = multi.recursive_iterator('ids')
| >>> next(iterator)
| (0, 0)
|
| Use :meth:`get_block` and get the next block indicated by the nested ids.
|
| >>> multi.get_block(next(iterator))
| UnstructuredGrid ...
|
| Use the iterator to :attr:`replace` all blocks with new blocks. Similar to a previous
| example, we use a filter but this time the operation is not performed in place.
|
| >>> iterator = multi.recursive_iterator('all', nested_ids=True)
| >>> for ids, _, block in iterator:
| ... multi.replace(ids, block.connectivity())
|
| Use ``node_type='parent'`` to get information about :class:`MultiBlock` nodes.
|
| >>> iterator = multi.recursive_iterator(node_type='parent')
|
| The iterator has ``8`` items. In this case this matches the number of blocks
| in the root block.
|
| >>> len(list(iterator))
| 8
|
| Use ``skip_empty`` to skip :class:`MultiBlock` nodes which have length ``0``
| and return their block ids.
|
| >>> iterator = multi.recursive_iterator(
| ... 'ids', node_type='parent', skip_empty=True
| ... )
| >>> ids = list(iterator)
|
| There are two non-empty blocks at index ``0`` and ``4``.
|
| >>> len(ids)
| 2
| >>> ids
| [(0,), (4,)]
|
| replace(self: 'MultiBlock', index: 'int | Sequence[int] | str', dataset: '_TypeMultiBlockLeaf') -> 'None'
| Replace dataset at index while preserving key name.
|
| Parameters
| ----------
| index : int | Sequence[int] | str
| Index or name of the block to replace. Specify a sequence of indices to replace
| a nested block.
|
| .. versionadded:: 0.45
|
| Allow indexing nested blocks.
|
| dataset : pyvista.DataSet or pyvista.MultiBlock
| Dataset for replacing the one at index.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.replace(1, pv.Sphere(center=(10, 10, 10)))
| >>> blocks.keys()
| ['cube', 'sphere']
| >>> np.allclose(blocks[1].center, [10.0, 10.0, 10.0])
| True
|
| Load a dataset with nested blocks.
|
| >>> multi = examples.download_cgns_multi()
|
| Get one of the blocks and extract its surface.
|
| >>> block = multi[0][3]
| >>> surface = block.extract_surface(algorithm=None)
|
| Replace the block.
|
| >>> multi.replace((0, 3), surface)
|
| This is similar to replacing the block directly with indexing but the block
| name is also preserved.
|
| >>> multi[0][3] = surface
|
| reverse(self: 'MultiBlock') -> 'None'
| Reverse MultiBlock in-place.
|
| Examples
| --------
| Reverse a multiblock.
|
| >>> import pyvista as pv
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.keys()
| ['cube', 'sphere']
| >>> blocks.reverse()
| >>> blocks.keys()
| ['sphere', 'cube']
|
| set_active_scalars(self: 'MultiBlock', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell', allow_missing: 'bool' = False) -> 'tuple[FieldAssociation, NumpyArray[float]]'
| Find the scalars by name and appropriately set it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str or None
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| allow_missing : bool, default: False
| Allow missing scalars in part of the composite dataset. If all
| blocks are missing the array, it will raise a ``KeyError``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the scalars activated.
|
| numpy.ndarray
| An array from the dataset matching ``name``.
|
| Notes
| -----
| The number of components of the data must match.
|
| set_block_name(self: 'MultiBlock', index: 'int | str', name: 'str | None') -> 'None'
| Set a block's string name at the specified index.
|
| Parameters
| ----------
| index : int | str
| Index or the dataset within the multiblock.
|
| .. versionadded:: 0.45
|
| Allow indexing by name.
|
| name : str, optional
| Name to assign to the block at ``index``. If ``None``, no name is
| assigned to the block.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = {
| ... 'cube': pv.Cube(),
| ... 'sphere': pv.Sphere(center=(2, 2, 0)),
| ... }
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.append(pv.Cone())
| >>> blocks.set_block_name(2, 'cone')
| >>> blocks.keys()
| ['cube', 'sphere', 'cone']
|
| shallow_copy(self: 'MultiBlock', to_copy: '_vtk.vtkMultiBlockDataSet', recursive: 'bool' = False) -> 'None'
| Shallow copy the given multiblock to this multiblock.
|
| Parameters
| ----------
| to_copy : MultiBlock | :vtk:`vtkMultiBlockDataSet`
| Data object to perform a shallow copy from.
|
| recursive : bool, default: False
| Also shallow-copy any nested :class:`~pyvista.MultiBlock` blocks. By
| default, only the root :class:`~pyvista.MultiBlock` is shallow-copied and
| any nested multi-blocks are not shallow-copied.
|
| wrap_nested(self: 'MultiBlock') -> 'None'
| Ensure that all nested data structures are wrapped as PyVista datasets.
|
| This is performed in place.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| block_types
| Return a set of all block type(s).
|
| .. versionadded:: 0.45
|
| See Also
| --------
| nested_block_types
|
| Examples
| --------
| Load a dataset with nested multi-blocks. Here we load
| :func:`~pyvista.examples.downloads.download_cgns_multi`.
|
| >>> from pyvista import examples
| >>> multi = examples.download_cgns_multi()
|
| The dataset has eight nested multi-block blocks, so the block types
| only contains :class:`MultiBlock`.
|
| >>> multi.block_types
| {<class 'pyvista.core.composite.MultiBlock'>}
|
| The nested blocks only contain a single mesh type so the nested block types
| only contains :class:`~pyvista.UnstructuredGrid`.
|
| >>> multi.nested_block_types
| {<class 'pyvista.core.pointset.StructuredGrid'>}
|
| bounds
| Find min/max for bounds across blocks.
|
| Returns
| -------
| tuple[float, float, float, float, float, float]
| Length 6 tuple of floats containing min/max along each axis.
|
| Examples
| --------
| Return the bounds across blocks.
|
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 2.5,
| z_min = -0.5,
| z_max = 0.5)
|
| is_all_polydata
| Return ``True`` when all the blocks are :class:`~pyvista.PolyData`.
|
| This method will recursively check if any internal blocks are also
| :class:`~pyvista.PolyData`.
|
| Returns
| -------
| bool
| Return ``True`` when all blocks are :class:`~pyvista.PolyData`.
|
| See Also
| --------
| as_polydata_blocks
| Convert all blocks to :class:`~pyvista.PolyData`.
| :meth:`~pyvista.DataObjectFilters.extract_surface`
| Convert this :class:`~pyvista.MultiBlock` to :class:`~pyvista.PolyData`.
|
| is_empty
| Return ``True`` if there are no blocks.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.MultiBlock()
| >>> mesh.is_empty
| True
|
| >>> mesh.append(pv.Sphere())
| >>> mesh.is_empty
| False
|
| is_heterogeneous
| Return ``True`` any two nested blocks have different type.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| is_homogeneous
| nested_block_types
| recursive_iterator
|
| Examples
| --------
| Load a dataset with nested multi-blocks. Here we load
| :func:`~pyvista.examples.downloads.download_mug`.
|
| >>> from pyvista import examples
| >>> multi = examples.download_mug()
|
| Show the :attr:`nested_block_types`.
|
| >>> multi.nested_block_types # doctest:+SKIP
| {<class 'pyvista.core.pointset.UnstructuredGrid'>, <class 'NoneType'>}
|
| Since there is more than one type, the dataset is heterogeneous.
|
| >>> multi.is_heterogeneous
| True
|
| is_homogeneous
| Return ``True`` if all nested blocks have the same type.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| is_heterogeneous
| nested_block_types
| recursive_iterator
|
| Examples
| --------
| Load a dataset with nested multi-blocks. Here we load
| :func:`~pyvista.examples.downloads.download_cgns_multi`.
|
| >>> from pyvista import examples
| >>> multi = examples.download_cgns_multi()
|
| Show the :attr:`nested_block_types`.
|
| >>> multi.nested_block_types
| {<class 'pyvista.core.pointset.StructuredGrid'>}
|
| Since there is only one type, the dataset is homogeneous.
|
| >>> multi.is_homogeneous
| True
|
| is_nested
| Return ``True`` if any blocks are a :class:`MultiBlock`.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| Create a simple :class:`MultiBlock`:
|
| >>> import pyvista as pv
| >>> multi = pv.MultiBlock([pv.Sphere()])
|
| It only contains a :class:`~pyvista.DataSet`, so it is not nested.
|
| >>> multi.is_nested
| False
|
| Nest it inside another MultiBlock.
|
| >>> nested = pv.MultiBlock([multi])
| >>> nested.is_nested
| True
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.length
| 4.3584
|
| nested_block_types
| Return a set of all nested block type(s).
|
| .. versionadded:: 0.45
|
| See Also
| --------
| block_types
| is_homogeneous
| is_heterogeneous
| recursive_iterator
|
| Examples
| --------
| Load a dataset with nested multi-blocks. Here we load
| :func:`~pyvista.examples.downloads.download_cgns_multi`.
|
| >>> from pyvista import examples
| >>> multi = examples.download_cgns_multi()
|
| The dataset has eight nested multi-block blocks, so the block types
| only contains :class:`MultiBlock`.
|
| >>> multi.block_types
| {<class 'pyvista.core.composite.MultiBlock'>}
|
| The nested blocks only contain a single mesh type so the nested block types
| only contains :class:`~pyvista.UnstructuredGrid`.
|
| >>> multi.nested_block_types
| {<class 'pyvista.core.pointset.StructuredGrid'>}
|
| volume
| Return the total volume of all meshes in this dataset.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.volume
| 1.7348
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.center # doctest:+SKIP
| array([1., 1., 0.])
|
| n_blocks
| Return the total number of blocks set.
|
| Returns
| -------
| int
| Total number of blocks set.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> blocks = pv.MultiBlock(data)
| >>> blocks.n_blocks
| 3
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.composite.CompositeFilters:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| combine(self, merge_points: 'bool' = False, tolerance=0.0)
| Combine all blocks into a single unstructured grid.
|
| Parameters
| ----------
| merge_points : bool, default: False
| Merge coincidental points.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Combined blocks.
|
| Examples
| --------
| Combine blocks within a multiblock without merging points.
|
| >>> import pyvista as pv
| >>> block = pv.MultiBlock(
| ... [
| ... pv.Cube(clean=False),
| ... pv.Cube(center=(1, 0, 0), clean=False),
| ... ]
| ... )
| >>> merged = block.combine()
| >>> merged.n_points
| 48
|
| Combine blocks and merge points
|
| >>> merged = block.combine(merge_points=True)
| >>> merged.n_points
| 12
|
| extract_geometry(self)
| Extract the surface the geometry of all blocks.
|
| Place this filter at the end of a pipeline before a polydata
| consumer such as a polydata mapper to extract geometry from
| all blocks and append them to one polydata object.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the composite dataset.
|
| generic_filter(self: 'MultiBlock', function: 'str | Callable[..., _TypeMultiBlockLeaf]', /, *args, **kwargs) -> 'MultiBlock'
| Apply any filter to all nested blocks recursively.
|
| This filter applies a user-specified function or method to all blocks in
| this :class:`~pyvista.MultiBlock`.
|
| .. note::
|
| If an ``inplace`` keyword is used, this ``MultiBlock`` is modified
| in-place along with all blocks.
|
| .. note::
|
| By default, the specified ``function`` is not applied to any ``None``
| blocks. These are simply skipped and passed through to the output.
|
| For advanced use, it is possible to apply the filter to ``None`` blocks
| by using the undocumented keyword ``_skip_none=False``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| function : Callable | str
| Callable function or name of the method to apply to each block. The function
| should accept a :class:`~pyvista.DataSet` as input and return either a
| :class:`~pyvista.DataSet` or :class:`~pyvista.MultiBlock` as output.
|
| *args : Any, optional
| Arguments to use with the specified ``function``.
|
| **kwargs : Any, optional
| Keyword arguments to use with the specified ``function``.
|
| Returns
| -------
| MultiBlock
| Filtered dataset.
|
| Raises
| ------
| RuntimeError
| Raised if the filter cannot be applied to any block for any reason. This
| overrides ``TypeError``, ``ValueError``, ``AttributeError`` errors when
| filtering.
|
| See Also
| --------
| pyvista.MultiBlock.flatten
| pyvista.MultiBlock.recursive_iterator
| pyvista.MultiBlock.clean
|
| Examples
| --------
| Create a :class:`~pyvista.MultiBlock` with various mesh types.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> volume = examples.load_uniform()
| >>> poly = examples.load_ant()
| >>> unstructured = examples.load_tetbeam()
| >>> multi = pv.MultiBlock([volume, poly, unstructured])
|
| >>> [type(block) for block in multi] # doctest: +NORMALIZE_WHITESPACE
| [<class 'pyvista.core.grid.ImageData'>,
| <class 'pyvista.core.pointset.PolyData'>,
| <class 'pyvista.core.pointset.UnstructuredGrid'>]
|
| Use the generic filter to apply :meth:`~pyvista.DataSet.cast_to_unstructured_grid`
| to all blocks.
|
| >>> filtered = multi.generic_filter('cast_to_unstructured_grid')
|
| >>> [type(block) for block in filtered] # doctest: +NORMALIZE_WHITESPACE
| [<class 'pyvista.core.pointset.UnstructuredGrid'>,
| <class 'pyvista.core.pointset.UnstructuredGrid'>,
| <class 'pyvista.core.pointset.UnstructuredGrid'>]
|
| Use the :meth:`~pyvista.DataSetFilters.partition` filter on all blocks.
| Any arguments can be specified as though the filter is being used directly.
|
| >>> filtered = multi.generic_filter('partition', 4, as_composite=True)
|
| Any function can be used as long as it returns a :class:`~pyvista.DataSet` or
| :class:`~pyvista.MultiBlock`. For example, we can normalize each block
| independently to have bounds between ``-0.5`` and ``0.5``.
|
| >>> def normalize_bounds(dataset):
| ... # Center the dataset
| ... dataset = dataset.translate(-np.array(dataset.center))
| ... # Scale the dataset
| ... factor = 1 / np.array(dataset.bounds_size)
| ... return dataset.scale(factor)
|
| >>> filtered = multi.generic_filter(normalize_bounds)
| >>> filtered
| MultiBlock (...)
| N Blocks: 3
| X Bounds: -5.000e-01, 5.000e-01
| Y Bounds: -5.000e-01, 5.000e-01
| Z Bounds: -5.000e-01, 5.000e-01
|
| The generic filter will fail if the filter can only be applied to some blocks
| but not others. For example, it is not possible to use the
| :meth:`~pyvista.ImageDataFilters.resample` filter generically since the
| ``MultiBlock`` above is heterogeneous and contains some blocks which are not
| :class:`~pyvista.ImageData`.
|
| >>> multi.generic_filter('resample', 0.5) # doctest:+SKIP
| RuntimeError: The filter 'resample' could not be applied to the block at index 1 with
| name 'Block-01' and type PolyData.
|
| Use a custom function instead to apply the generic filter conditionally. Here we
| filter the image blocks but simply pass-through a copy of any other blocks.
|
| >>> def conditional_resample(dataset, *args, **kwargs):
| ... if isinstance(dataset, pv.ImageData):
| ... return dataset.resample(*args, **kwargs)
| ... return dataset.copy()
|
| >>> filtered = multi.generic_filter(conditional_resample, 0.5)
|
| outline(self: 'MultiBlock', generate_faces: 'bool' = False, nested: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the all blocks in this composite dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box.
|
| nested : bool, default: False
| If ``True``, these creates individual outlines for each nested dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the outline.
|
| outline_corners(self: 'MultiBlock', factor=0.2, nested: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the corners for the all blocks in this composite dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| nested : bool, default: False
| If ``True``, these creates individual outlines for each nested dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from collections.abc.MutableSequence:
|
| __iadd__(self, values)
|
| clear(self)
| S.clear() -> None -- remove all items from S
|
| remove(self, value)
| S.remove(value) -- remove first occurrence of value.
| Raise ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Methods inherited from collections.abc.Sequence:
|
| __contains__(self, value)
|
| __iter__(self)
|
| __reversed__(self)
|
| count(self, value)
| S.count(value) -> integer -- return number of occurrences of value
|
| index(self, value, start=0, stop=None)
| S.index(value, [start, [stop]]) -> integer -- return first index of value.
| Raises ValueError if the value is not present.
|
| Supporting start and stop arguments is optional, but
| recommended.
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.abc.Reversible:
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.abc.Iterable:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet:
|
| GetBlock(...)
| GetBlock(self, blockno:int) -> vtkDataObject
| C++: vtkDataObject *GetBlock(unsigned int blockno)
|
| Returns the block at the given index. It is recommended that one
| uses the iterators to iterate over composite datasets rather than
| using this API.
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkMultiBlockDataSet
| C++: static vtkMultiBlockDataSet *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkMultiBlockDataSet
| C++: static vtkMultiBlockDataSet *GetData(vtkInformationVector *v,
| int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return class name of data type (see vtkType.h for definitions).
|
| GetMetaData(...)
| GetMetaData(self, blockno:int) -> vtkInformation
| C++: vtkInformation *GetMetaData(unsigned int blockno)
| GetMetaData(self, iter:vtkCompositeDataIterator) -> vtkInformation
| C++: vtkInformation *GetMetaData(vtkCompositeDataIterator *iter)
| override;
|
| Returns the meta-data for the block. If none is already present,
| a new vtkInformation object will be allocated. Use HasMetaData to
| avoid allocating vtkInformation objects.
|
| GetNumberOfBlocks(...)
| GetNumberOfBlocks(self) -> int
| C++: unsigned int GetNumberOfBlocks()
|
| Returns the number of blocks.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| HasMetaData(...)
| HasMetaData(self, blockno:int) -> int
| C++: vtkTypeBool HasMetaData(unsigned int blockno)
| HasMetaData(self, iter:vtkCompositeDataIterator) -> int
| C++: vtkTypeBool HasMetaData(vtkCompositeDataIterator *iter)
| override;
|
| Returns true if meta-data is available for a given block.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkMultiBlockDataSet
| C++: vtkMultiBlockDataSet *NewInstance()
|
| RemoveBlock(...)
| RemoveBlock(self, blockno:int) -> None
| C++: void RemoveBlock(unsigned int blockno)
|
| Remove the given block from the dataset.
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkMultiBlockDataSet
| C++: static vtkMultiBlockDataSet *SafeDownCast(vtkObjectBase *o)
|
| SetBlock(...)
| SetBlock(self, blockno:int, block:vtkDataObject) -> None
| C++: void SetBlock(unsigned int blockno, vtkDataObject *block)
|
| Sets the data object as the given block. The total number of
| blocks will be resized to fit the requested block no.
|
| @remark while most vtkDataObject subclasses, including
| vtkMultiBlockDataSet as acceptable as a block,
| `vtkPartitionedDataSet`, `vtkPartitionedDataSetCollection`, and
| `vtkUniformGridAMR` are not valid.
|
| SetNumberOfBlocks(...)
| SetNumberOfBlocks(self, numBlocks:int) -> None
| C++: void SetNumberOfBlocks(unsigned int numBlocks)
|
| Set the number of blocks. This will cause allocation if the new
| number of blocks is greater than the current size. All new blocks
| are initialized to null.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet:
|
| __this__
| Pointer to the C++ object.
|
| data_object_type
| read-only, calls GetDataObjectType
|
| number_of_blocks
| read-write, calls GetNumberOfBlocks/SetNumberOfBlocks
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet:
|
| __vtkname__ = 'vtkMultiBlockDataSet'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObjectTree:
|
| CompositeShallowCopy(...)
| CompositeShallowCopy(self, src:vtkCompositeDataSet) -> None
| C++: void CompositeShallowCopy(vtkCompositeDataSet *src) override;
|
| CompositeShallow, Shallow and Deep copy.
|
| CopyStructure(...)
| CopyStructure(self, input:vtkCompositeDataSet) -> None
| C++: void CopyStructure(vtkCompositeDataSet *input) override;
|
| Copies the tree structure from the input. All pointers to
| non-composite data objects are initialized to nullptr. This also
| shallow copies the meta data associated with all the nodes.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated.
|
| GetChild(...)
| GetChild(self, index:int) -> vtkDataObject
| C++: vtkDataObject *GetChild(unsigned int index)
|
| Returns a child dataset at a given index.
|
| GetChildMetaData(...)
| GetChildMetaData(self, index:int) -> vtkInformation
| C++: vtkInformation *GetChildMetaData(unsigned int index)
|
| Returns the meta-data at a given index. If the index is valid,
| however, no information object is set, then a new one will
| created and returned. To avoid unnecessary creation, use
| HasMetaData().
|
| GetDataSet(...)
| GetDataSet(self, iter:vtkCompositeDataIterator) -> vtkDataObject
| C++: vtkDataObject *GetDataSet(vtkCompositeDataIterator *iter)
| override;
| GetDataSet(self, flatIndex:int) -> vtkDataObject
| C++: virtual vtkDataObject *GetDataSet(unsigned int flatIndex)
|
| Returns the dataset located at the position pointed by the
| iterator. The iterator does not need to be iterating over this
| dataset itself. It can be an iterator for composite dataset with
| similar structure (achieved by using CopyStructure).
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| Returns the total number of cells of all blocks. This will
| iterate over all blocks and call GetNumberOfPoints() so it might
| be expensive.
|
| GetNumberOfChildren(...)
| GetNumberOfChildren(self) -> int
| C++: unsigned int GetNumberOfChildren()
|
| Get the number of children.
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| Returns the total number of points of all blocks. This will
| iterate over all blocks and call GetNumberOfPoints() so it might
| be expansive.
|
| HasChildMetaData(...)
| HasChildMetaData(self, index:int) -> int
| C++: vtkTypeBool HasChildMetaData(unsigned int index)
|
| Returns if meta-data information is available for the given child
| index. Returns 1 is present, 0 otherwise.
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Restore data object to initial state,
|
| NewIterator(...)
| NewIterator(self) -> vtkCompositeDataIterator
| C++: vtkCompositeDataIterator *NewIterator() override;
|
| Return a new iterator (the iterator has to be deleted by user).
|
| * Use NewTreeIterator when you have a pointer to a
| vtkDataObjectTree
| * and NewIterator when you have a pointer to a
| vtkCompositeDataSet;
| * NewIterator is inherited and calls NewTreeIterator internally.
|
| NewTreeIterator(...)
| NewTreeIterator(self) -> vtkDataObjectTreeIterator
| C++: virtual vtkDataObjectTreeIterator *NewTreeIterator()
|
| Return a new iterator (the iterator has to be deleted by user).
|
| SetDataSet(...)
| SetDataSet(self, iter:vtkCompositeDataIterator,
| dataObj:vtkDataObject) -> None
| C++: void SetDataSet(vtkCompositeDataIterator *iter,
| vtkDataObject *dataObj) override;
|
| Sets the data set at the location pointed by the iterator. The
| iterator does not need to be iterating over this dataset itself.
| It can be any composite datasite with similar structure (achieved
| by using CopyStructure).
|
| SetDataSetFrom(...)
| SetDataSetFrom(self, iter:vtkDataObjectTreeIterator,
| dataObj:vtkDataObject) -> None
| C++: void SetDataSetFrom(vtkDataObjectTreeIterator *iter,
| vtkDataObject *dataObj)
|
| Sets the data at the location provided by a
| vtkDataObjectTreeIterator
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the data up to the array
| pointers only. The implementation is delegated to the differenent
| subclasses. If you want to copy the actual data, @see DeepCopy.
|
| This method shallow copy the field data and copy the internal
| structure.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObjectTree:
|
| number_of_cells
| read-only, calls GetNumberOfCells
|
| number_of_children
| read-only, calls GetNumberOfChildren
|
| number_of_points
| read-only, calls GetNumberOfPoints
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkCompositeDataSet:
|
| CURRENT_PROCESS_CAN_LOAD_BLOCK(...)
| CURRENT_PROCESS_CAN_LOAD_BLOCK() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CURRENT_PROCESS_CAN_LOAD_BLOCK(
| )
|
| Key used to indicate that the current process can load the data
| in the node. Used for parallel readers where the nodes are
| assigned to the processes by the reader to indicate further down
| the pipeline which nodes will be on which processes.
| ***THIS IS AN EXPERIMENTAL KEY SUBJECT TO CHANGE WITHOUT
| NOTICE***\ingroup InformationKeys
|
| GetBounds(...)
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return the geometric bounding box in the form (xmin,xmax,
| ymin,ymax, zmin,zmax). Note that if the composite dataset
| contains abstract types (i.e., non vtkDataSet types) such as
| tables these will be ignored by the method. In cases where no
| vtkDataSet is contained in the composite dataset then the
| returned bounds will be undefined. THIS METHOD IS THREAD SAFE IF
| FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT
| MODIFIED.
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| NAME(...)
| NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *NAME()
|
| Key used to put node name in the meta-data associated with a
| node.\ingroup InformationKeys
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: virtual void Crop(const int *updateExtent)
|
| This method crops the data object (if necessary) so that the
| extent matches the update extent.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: virtual vtkFieldData *GetAttributesAsFieldData(int type)
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: virtual int GetExtentType()
|
| The ExtentType will be left as VTK_PIECES_EXTENT for data objects
| such as vtkPolyData and vtkUnstructuredGrid. The ExtentType will
| be changed to VTK_3D_EXTENT for data objects with 3D structure
| such as vtkImageData (and its subclass vtkStructuredPoints),
| vtkRectilinearGrid, and vtkStructuredGrid. The default is the
| have an extent in pieces, with only one piece (no streaming
| possible).
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: virtual vtkUnsignedCharArray *GetGhostArray(int type)
|
| Returns the ghost arrays of the data object of the specified
| attribute type. The type may be: POINT - Defined in
| vtkDataSet subclasses CELL - Defined in vtkDataSet subclasses.
| The other attribute types, will return nullptr since ghosts
| arrays are not defined for now outside of point or cell.
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Data objects are composite objects and need to check each part
| for MTime. The information object also needs to be considered.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| extent_type
| read-only, calls GetExtentType
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| m_time
| read-only, calls GetMTime
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
DATA
CellLiteral = typing.Literal[<FieldAssociation.CELL: 1>, 'cell']
ClassVar = typing.ClassVar
Special type construct to mark class variables.
An annotation wrapped in ClassVar indicates that a given
attribute is intended to be used as a class variable and
should not be set on instances of that class.
Usage::
class Starship:
stats: ClassVar[dict[str, int]] = {} # class variable
damage: int = 10 # instance variable
ClassVar accepts only types and cannot be further subscribed.
Note that ClassVar is not a class itself, and should not
be used with isinstance() or issubclass().
FieldLiteral = typing.Literal[<FieldAssociation.NONE: 2>, 'field']
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
NoReturn = typing.NoReturn
Special type indicating functions that never return.
Example::
from typing import NoReturn
def stop() -> NoReturn:
raise Exception('no way')
NoReturn can also be used as a bottom type, a type that
has no values. Starting in Python 3.11, the Never type should
be used for this concept instead. Type checkers should treat the two
equivalently.
PointLiteral = typing.Literal[<FieldAssociation.POINT: 0>, 'point']
Self = typing.Self
Used to spell the type of "self" in classes.
Example::
from typing import Self
class Foo:
def return_self(self) -> Self:
...
return self
This is especially useful for:
- classmethods that are used as alternative constructors
- annotating an `__enter__` method which returns self
TYPE_CHECKING = False
TypedDict = typing_extensions.TypedDict
A simple typed namespace. At runtime it is equivalent to a plain dict.
TypedDict creates a dictionary type such that a type checker will expect all
instances to have a certain set of keys, where each key is
associated with a value of a consistent type. This expectation
is not checked at runtime.
Usage::
class Point2D(TypedDict):
x: int
y: int
label: str
a: Point2D = {'x': 1, 'y': 2, 'label': 'good'} # OK
b: Point2D = {'z': 3, 'label': 'bad'} # Fails type check
assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')
The type info can be accessed via the Point2D.__annotations__ dict, and
the Point2D.__required_keys__ and Point2D.__optional_keys__ frozensets.
TypedDict supports an additional equivalent form::
Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})
By default, all keys must be present in a TypedDict. It is possible
to override this by specifying totality::
class Point2D(TypedDict, total=False):
x: int
y: int
This means that a Point2D TypedDict can have any of the keys omitted. A type
checker is only expected to support a literal False or True as the value of
the total argument. True is the default, and makes all items defined in the
class body be required.
The Required and NotRequired special forms can also be used to mark
individual keys as being required or not required::
class Point2D(TypedDict):
x: int # the "x" key must always be present (Required is the default)
y: NotRequired[int] # the "y" key can be omitted
See PEP 655 for more details on Required and NotRequired.
USER_DICT_KEY = '_PYVISTA_USER_DICT'
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
Unpack = typing.Unpack
Type unpack operator.
The type unpack operator takes the child types from some container type,
such as `tuple[int, str]` or a `TypeVarTuple`, and 'pulls them out'.
For example::
# For some generic class `Foo`:
Foo[Unpack[tuple[int, str]]] # Equivalent to Foo[int, str]
Ts = TypeVarTuple('Ts')
# Specifies that `Bar` is generic in an arbitrary number of types.
# (Think of `Ts` as a tuple of an arbitrary number of individual
# `TypeVar`s, which the `Unpack` is 'pulling out' directly into the
# `Generic[]`.)
class Bar(Generic[Unpack[Ts]]): ...
Bar[int] # Valid
Bar[int, str] # Also valid
From Python 3.11, this can also be done using the `*` operator::
Foo[*tuple[int, str]]
class Bar(Generic[*Ts]): ...
And from Python 3.12, it can be done using built-in syntax for generics::
Foo[*tuple[int, str]]
class Bar[*Ts]: ...
The operator can also be used along with a `TypedDict` to annotate
`**kwargs` in a function signature::
class Movie(TypedDict):
name: str
year: int
# This function expects two keyword arguments - *name* of type `str` and
# *year* of type `int`.
def foo(**kwargs: Unpack[Movie]): ...
Note that there is only some runtime checking of this operator. Not
everything the runtime allows may be accepted by static type checkers.
For more information, see PEPs 646 and 692.
vtk_version_info = VTKVersionInfo(major=9, minor=6, micro=2)
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\composite.py
pyvista.conditional_decorator
Python Library Documentation: class conditional_decorator in module pyvista.core.utilities.misc class conditional_decorator(builtins.object) | conditional_decorator(dec, condition) -> 'None' | | Conditional decorator for methods. | | Parameters | ---------- | dec : callable | The decorator to be applied conditionally. | condition : bool | Condition to match. If ``True``, the decorator is applied. If | ``False``, the function is returned unchanged. | | Methods defined here: | | __call__(self, func) | Call the decorated function if condition is matched. | | __init__(self, dec, condition) -> 'None' | Initialize. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object
pyvista.config
Python Library Documentation: module pyvista.core.config in pyvista.core
NAME
pyvista.core.config - Global configuration for PyVista core (non-plotting) behavior.
DESCRIPTION
This module exposes :data:`pyvista.global_config`, a singleton :class:`Config`
instance that holds process-wide settings for the ``pyvista.core`` layer. It is
a sibling to :data:`pyvista.global_theme` (defined in
:mod:`pyvista.plotting.themes`) and shares the same machinery: both inherit
from :class:`_ConfigBase` and behave the same way for attribute access,
dict-style item access, ``to_dict`` / ``from_dict`` serialization, and equality
comparison.
The base class lives here in :mod:`pyvista.core` rather than in
:mod:`pyvista.plotting` so that the core layer does not depend on plotting.
:mod:`pyvista.plotting.themes` imports :class:`_ConfigBase` from here to build
the plotting theme hierarchy.
To add a new core setting:
1. Add an underscore-prefixed slot to ``Config.__slots__``.
2. Initialize it in :meth:`Config.__init__`.
3. Expose it via a public ``@property`` getter / setter pair that reads and
writes the underscore slot. The setter should validate its input.
That is the same pattern used by every theme subclass, so the two hierarchies
stay symmetrical and ``to_dict`` / ``from_dict`` round-tripping works without
any extra code.
Examples
--------
Disable the default array-length check that :func:`pyvista.wrap` performs on
every VTK object it wraps:
>>> import pyvista as pv
>>> pv.global_config.validate_on_wrap = False
>>> pv.global_config.validate_on_wrap = True # restore default
Access a setting via dict-style lookup:
>>> pv.global_config['validate_on_wrap']
True
Show the VTK-inherited API in :func:`dir` (and IDE tab-completion):
>>> pv.global_config.show_vtk_api = True
>>> pv.global_config.show_vtk_api = False # restore default
Dump the current config to a plain dict (useful for logging or round-tripping):
>>> pv.global_config.to_dict()
{'show_vtk_api': False, 'validate_on_wrap': True}
CLASSES
_ConfigBase(builtins.object)
Config
class Config(_ConfigBase)
| Config() -> 'None'
|
| PyVista core configuration.
|
| Holds process-wide settings that affect ``pyvista.core`` behavior. The
| singleton instance is exposed as ``pyvista.global_config``. This is the
| sibling of ``pyvista.global_theme`` for plotting (rendering) settings.
|
| Examples
| --------
| Disable the default array-length check performed by :func:`pyvista.wrap`:
|
| >>> import pyvista as pv
| >>> pv.global_config.validate_on_wrap = False
| >>> pv.global_config.validate_on_wrap = True # restore default
|
| Method resolution order:
| Config
| _ConfigBase
| builtins.object
|
| Methods defined here:
|
| __init__(self) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| show_vtk_api
| Return or set whether VTK-inherited attributes appear in :func:`dir`.
|
| When ``False`` (the default), attributes inherited from VTK base
| classes are hidden from :func:`dir` and tab-completion on PyVista
| objects that wrap VTK types (data objects, :class:`~pyvista.Renderer`,
| :class:`~pyvista.Actor`, :class:`~pyvista.Property`, etc.). This keeps
| the public surface curated for data-science IDEs such as Positron's
| Variables pane and VS Code's Jupyter extension, and for IPython /
| Jupyter tab-completion. VTK methods remain fully callable regardless
| of this setting.
|
| When ``True``, the full VTK API is enumerated alongside the PyVista
| API, which is useful for VTK developers who want to discover the raw
| VTK method surface via introspection.
|
| .. warning::
|
| This option requires runtime inspection and does not work with all developer
| tools, e.g. it has no effect when using PyCharm. This is because it relies on
| calling the object's ``__dir__`` method for generating auto-completion
| suggestions. Tools like PyCharm that only use static analysis for
| auto-completion are therefore unaffected.
|
| Notes
| -----
| The snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| controlled separately by :func:`pyvista.vtk_snake_case`. When
| snake_case is not ``'allow'`` (the default), those names are hidden
| from :func:`dir` regardless of this setting, because accessing them
| would already raise ``PyVistaAttributeError``.
| Enabling snake_case surfaces the snake_case names in :func:`dir`;
| ``show_vtk_api`` only controls the CamelCase VTK API.
|
| .. versionadded:: 0.48
|
| Examples
| --------
| >>> import pyvista as pv
| >>> pv.global_config.show_vtk_api
| False
| >>> pv.global_config.show_vtk_api = True
| >>> pv.global_config.show_vtk_api = False # restore default
|
| validate_on_wrap
| Return or set whether :func:`pyvista.wrap` validates data arrays.
|
| When ``True`` (the default), :func:`pyvista.wrap` performs a cheap
| array-length sanity check on every VTK object it wraps and emits a
| :class:`~pyvista.InvalidMeshWarning` if any point or cell data array
| has a tuple count that does not match the dataset's point or cell
| count. Set to ``False`` to skip this check globally when the cost
| matters in tight loops and the caller trusts their inputs.
|
| Notes
| -----
| Per-call control is also available via the ``validate`` keyword on
| :func:`pyvista.wrap`, :func:`pyvista.read`, and
| :meth:`pyvista.BaseReader.read`. The per-call keyword takes
| precedence; this global setting is consulted only when the per-call
| keyword is left at its default ``None``.
|
| .. versionadded:: 0.48
|
| Examples
| --------
| >>> import pyvista as pv
| >>> pv.global_config.validate_on_wrap
| True
| >>> pv.global_config.validate_on_wrap = False
| >>> pv.global_config.validate_on_wrap = True # restore default
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from _ConfigBase:
|
| __eq__(self, other: 'object') -> 'bool'
| Return self==value.
|
| __getitem__(self, key: 'str') -> 'Any'
| Get a value via a key (backwards-compatible dict access).
|
| __setitem__(self, key: 'str', value: 'Any') -> 'None'
| Set a value via a key (backwards-compatible dict access).
|
| to_dict(self) -> 'dict[str, Any]'
| Return config parameters as a dictionary.
|
| Returns
| -------
| dict
| Mapping of public attribute name to its current value. Nested
| config objects are recursively serialized via their own
| ``to_dict``. Names listed in :attr:`_TO_DICT_SKIP` are omitted.
|
| ----------------------------------------------------------------------
| Class methods inherited from _ConfigBase:
|
| from_dict(dict_: 'dict[str, Any]') -> 'Self'
| Create an instance from a dictionary of attribute values.
|
| Parameters
| ----------
| dict_ : dict
| Mapping of public attribute name to value, as produced by
| :meth:`to_dict`. Nested config objects are recursively
| reconstructed via their own ``from_dict``.
|
| Returns
| -------
| Self
| New instance of ``cls`` populated from ``dict_``.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from _ConfigBase:
|
| __hash__ = None
DATA
ClassVar = typing.ClassVar
Special type construct to mark class variables.
An annotation wrapped in ClassVar indicates that a given
attribute is intended to be used as a class variable and
should not be set on instances of that class.
Usage::
class Starship:
stats: ClassVar[dict[str, int]] = {} # class variable
damage: int = 10 # instance variable
ClassVar accepts only types and cannot be further subscribed.
Note that ClassVar is not a class itself, and should not
be used with isinstance() or issubclass().
TYPE_CHECKING = False
global_config = PyVista Config
--------------
show_vtk_api ...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\config.py
pyvista.contextlib
Python Library Documentation: module contextlib
NAME
contextlib - Utilities for with-statement contexts. See PEP 343.
MODULE REFERENCE
https://docs.python.org/3.12/library/contextlib.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
CLASSES
abc.ABC(builtins.object)
AbstractAsyncContextManager
AsyncExitStack(_BaseExitStack, AbstractAsyncContextManager)
aclosing
AbstractContextManager
ExitStack(_BaseExitStack, AbstractContextManager)
chdir
closing
nullcontext(AbstractContextManager, AbstractAsyncContextManager)
suppress
builtins.object
ContextDecorator
_BaseExitStack(builtins.object)
AsyncExitStack(_BaseExitStack, AbstractAsyncContextManager)
ExitStack(_BaseExitStack, AbstractContextManager)
_RedirectStream(AbstractContextManager)
redirect_stderr
redirect_stdout
class AbstractAsyncContextManager(abc.ABC)
| An abstract base class for asynchronous context managers.
|
| Method resolution order:
| AbstractAsyncContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| async __aenter__(self)
| Return `self` upon entering the runtime context.
|
| async __aexit__(self, exc_type, exc_value, traceback)
| Raise any exception triggered within the runtime context.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'__aexit__'})
|
| __annotations__ = {}
class AbstractContextManager(abc.ABC)
| An abstract base class for context managers.
|
| Method resolution order:
| AbstractContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, exc_type, exc_value, traceback)
| Raise any exception triggered within the runtime context.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'__exit__'})
|
| __annotations__ = {}
class AsyncExitStack(_BaseExitStack, AbstractAsyncContextManager)
| Async context manager for dynamic management of a stack of exit
| callbacks.
|
| For example:
| async with AsyncExitStack() as stack:
| connections = [await stack.enter_async_context(get_connection())
| for i in range(5)]
| # All opened connections will automatically be released at the
| # end of the async with statement, even if attempts to open a
| # connection later in the list raise an exception.
|
| Method resolution order:
| AsyncExitStack
| _BaseExitStack
| AbstractAsyncContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| async __aenter__(self)
| Return `self` upon entering the runtime context.
|
| async __aexit__(self, *exc_details)
| Raise any exception triggered within the runtime context.
|
| async aclose(self)
| Immediately unwind the context stack.
|
| async enter_async_context(self, cm)
| Enters the supplied async context manager.
|
| If successful, also pushes its __aexit__ method as a callback and
| returns the result of the __aenter__ method.
|
| push_async_callback(self, callback, /, *args, **kwds)
| Registers an arbitrary coroutine function and arguments.
|
| Cannot suppress exceptions.
|
| push_async_exit(self, exit)
| Registers a coroutine function with the standard __aexit__ method
| signature.
|
| Can suppress exceptions the same way __aexit__ method can.
| Also accepts any object with an __aexit__ method (registering a call
| to the method instead of the object itself).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from _BaseExitStack:
|
| __init__(self)
| Initialize self. See help(type(self)) for accurate signature.
|
| callback(self, callback, /, *args, **kwds)
| Registers an arbitrary callback and arguments.
|
| Cannot suppress exceptions.
|
| enter_context(self, cm)
| Enters the supplied context manager.
|
| If successful, also pushes its __exit__ method as a callback and
| returns the result of the __enter__ method.
|
| pop_all(self)
| Preserve the context stack by transferring it to a new instance.
|
| push(self, exit)
| Registers a callback with the standard __exit__ method signature.
|
| Can suppress exceptions the same way __exit__ method can.
| Also accepts any object with an __exit__ method (registering a call
| to the method instead of the object itself).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _BaseExitStack:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractAsyncContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
class ContextDecorator(builtins.object)
| A base class or mixin that enables context managers to work as decorators.
|
| Methods defined here:
|
| __call__(self, func)
| Call self as a function.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class ExitStack(_BaseExitStack, AbstractContextManager)
| Context manager for dynamic management of a stack of exit callbacks.
|
| For example:
| with ExitStack() as stack:
| files = [stack.enter_context(open(fname)) for fname in filenames]
| # All opened files will automatically be closed at the end of
| # the with statement, even if attempts to open files later
| # in the list raise an exception.
|
| Method resolution order:
| ExitStack
| _BaseExitStack
| AbstractContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, *exc_details)
| Raise any exception triggered within the runtime context.
|
| close(self)
| Immediately unwind the context stack.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from _BaseExitStack:
|
| __init__(self)
| Initialize self. See help(type(self)) for accurate signature.
|
| callback(self, callback, /, *args, **kwds)
| Registers an arbitrary callback and arguments.
|
| Cannot suppress exceptions.
|
| enter_context(self, cm)
| Enters the supplied context manager.
|
| If successful, also pushes its __exit__ method as a callback and
| returns the result of the __enter__ method.
|
| pop_all(self)
| Preserve the context stack by transferring it to a new instance.
|
| push(self, exit)
| Registers a callback with the standard __exit__ method signature.
|
| Can suppress exceptions the same way __exit__ method can.
| Also accepts any object with an __exit__ method (registering a call
| to the method instead of the object itself).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _BaseExitStack:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
class aclosing(AbstractAsyncContextManager)
| aclosing(thing)
|
| Async context manager for safely finalizing an asynchronously cleaned-up
| resource such as an async generator, calling its ``aclose()`` method.
|
| Code like this:
|
| async with aclosing(<module>.fetch(<arguments>)) as agen:
| <block>
|
| is equivalent to this:
|
| agen = <module>.fetch(<arguments>)
| try:
| <block>
| finally:
| await agen.aclose()
|
| Method resolution order:
| aclosing
| AbstractAsyncContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| async __aenter__(self)
| Return `self` upon entering the runtime context.
|
| async __aexit__(self, *exc_info)
| Raise any exception triggered within the runtime context.
|
| __init__(self, thing)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractAsyncContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from AbstractAsyncContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class chdir(AbstractContextManager)
| chdir(path)
|
| Non thread-safe context manager to change the current working directory.
|
| Method resolution order:
| chdir
| AbstractContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, *excinfo)
| Raise any exception triggered within the runtime context.
|
| __init__(self, path)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from AbstractContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class closing(AbstractContextManager)
| closing(thing)
|
| Context to automatically close something at the end of a block.
|
| Code like this:
|
| with closing(<module>.open(<arguments>)) as f:
| <block>
|
| is equivalent to this:
|
| f = <module>.open(<arguments>)
| try:
| <block>
| finally:
| f.close()
|
| Method resolution order:
| closing
| AbstractContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, *exc_info)
| Raise any exception triggered within the runtime context.
|
| __init__(self, thing)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from AbstractContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class nullcontext(AbstractContextManager, AbstractAsyncContextManager)
| nullcontext(enter_result=None)
|
| Context manager that does no additional processing.
|
| Used as a stand-in for a normal context manager, when a particular
| block of code is only sometimes used with a normal context manager:
|
| cm = optional_cm if condition else nullcontext()
| with cm:
| # Perform operation, using optional_cm if condition is True
|
| Method resolution order:
| nullcontext
| AbstractContextManager
| AbstractAsyncContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| async __aenter__(self)
| Return `self` upon entering the runtime context.
|
| async __aexit__(self, *excinfo)
| Raise any exception triggered within the runtime context.
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, *excinfo)
| Raise any exception triggered within the runtime context.
|
| __init__(self, enter_result=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from AbstractContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class redirect_stderr(_RedirectStream)
| redirect_stderr(new_target)
|
| Context manager for temporarily redirecting stderr to another file.
|
| Method resolution order:
| redirect_stderr
| _RedirectStream
| AbstractContextManager
| abc.ABC
| builtins.object
|
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from _RedirectStream:
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, exctype, excinst, exctb)
| Raise any exception triggered within the runtime context.
|
| __init__(self, new_target)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from AbstractContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class redirect_stdout(_RedirectStream)
| redirect_stdout(new_target)
|
| Context manager for temporarily redirecting stdout to another file.
|
| # How to send help() to stderr
| with redirect_stdout(sys.stderr):
| help(dir)
|
| # How to write help() to a file
| with open('help.txt', 'w') as f:
| with redirect_stdout(f):
| help(pow)
|
| Method resolution order:
| redirect_stdout
| _RedirectStream
| AbstractContextManager
| abc.ABC
| builtins.object
|
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from _RedirectStream:
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, exctype, excinst, exctb)
| Raise any exception triggered within the runtime context.
|
| __init__(self, new_target)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from AbstractContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class suppress(AbstractContextManager)
| suppress(*exceptions)
|
| Context manager to suppress specified exceptions
|
| After the exception is suppressed, execution proceeds with the next
| statement following the with statement.
|
| with suppress(FileNotFoundError):
| os.remove(somefile)
| # Execution still resumes here if the file was already removed
|
| Method resolution order:
| suppress
| AbstractContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, exctype, excinst, exctb)
| Raise any exception triggered within the runtime context.
|
| __init__(self, *exceptions)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from AbstractContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
asynccontextmanager(func)
@asynccontextmanager decorator.
Typical usage:
@asynccontextmanager
async def some_async_generator(<arguments>):
<setup>
try:
yield <value>
finally:
<cleanup>
This makes this:
async with some_async_generator(<arguments>) as <variable>:
<body>
equivalent to this:
<setup>
try:
<variable> = <value>
<body>
finally:
<cleanup>
contextmanager(func)
@contextmanager decorator.
Typical usage:
@contextmanager
def some_generator(<arguments>):
<setup>
try:
yield <value>
finally:
<cleanup>
This makes this:
with some_generator(<arguments>) as <variable>:
<body>
equivalent to this:
<setup>
try:
<variable> = <value>
<body>
finally:
<cleanup>
DATA
__all__ = ['asynccontextmanager', 'contextmanager', 'closing', 'nullco...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\contextlib.py
pyvista.convert_array
Python Library Documentation: function convert_array in module pyvista.core.utilities.arrays
convert_array(arr: 'npt.ArrayLike | _vtk.vtkAbstractArray | None', name: 'str | None' = None, deep: 'bool' = False, array_type: 'int | None' = None) -> 'npt.NDArray[Any] | _vtk.vtkAbstractArray | None'
Convert a NumPy array to a :vtk:`vtkDataArray` or vice versa.
Parameters
----------
arr : np.ndarray | :vtk:`vtkDataArray`
A numpy array or :vtk:`vtkDataArray` to convert.
name : str, optional
The name of the data array for VTK.
deep : bool, default: False
If input is numpy array then deep copy values.
array_type : int, optional
VTK array type ID as specified in ``vtkType.h``.
Returns
-------
output : :vtk:`vtkDataArray` | numpy.ndarray
The converted array. If input is a :class:`numpy.ndarray` then
returns :vtk:`vtkDataArray` or if input is :vtk:`vtkDataArray` then
returns NumPy ``ndarray``.
pyvista.convert_string_array
Python Library Documentation: function convert_string_array in module pyvista.core.utilities.arrays
convert_string_array(arr: 'str | npt.NDArray[np.str_] | _vtk.vtkStringArray', name: 'str | None' = None) -> 'npt.NDArray[np.str_] | _vtk.vtkStringArray'
Convert a numpy array of strings to a :vtk:`vtkStringArray` or vice versa.
If a scalar string is provided, it is converted to a :vtk:`vtkCharArray`
Parameters
----------
arr : numpy.ndarray | str
Numpy string array to convert.
name : str, optional
Name to set the :vtk:`vtkStringArray` to.
Returns
-------
:vtk:`vtkStringArray`
VTK string array.
Notes
-----
Note that this is terribly inefficient. If you have ideas on how
to make this faster, please consider opening a pull request.
pyvista.core
Python Library Documentation: package pyvista.core in pyvista
NAME
pyvista.core - Core routines.
PACKAGE CONTENTS
_typing_core (package)
_validation (package)
_vtk_utilities
cell
celltype
composite
config
dataobject
dataset
datasetattributes
errors
filters (package)
formatting_html
grid
objects
partitioned
pointset
pyvista_ndarray
static (package)
utilities (package)
wrappers
SUBMODULES
accessor_registry
arrays
cell_quality
cells
features
fileio
geometric_objects
geometric_sources
helpers
image_sources
misc
observers
parametric_objects
points
reader
reader_registry
state_manager
transform
transformations
writer
writer_registry
DATA
ArrayLike = typing.Union[numpy.ndarray[typing.Any, numpy.dty...darray[...
CellArrayLike = typing.Union[numpy.ndarray[typing.Any, numpy.dty...t]]...
CellsLike = typing.Union[numpy.ndarray[typing.Any, numpy.dty...nce[num...
InteractionEventType = typing.Union[typing.Literal['end', 'start', 'al...
MatrixLike = typing.Union[numpy.ndarray[typing.Any, numpy.dty....ndarr...
Number = typing.Union[int, float]
NumberType = ~NumberType
NumpyArray = numpy.ndarray[typing.Any, numpy.dtype[~NumberType]]
RotationLike = typing.Union[numpy.ndarray[typing.Any, numpy.dty...floa...
TransformLike = typing.Union[numpy.ndarray[typing.Any, numpy.dty...4x4...
VectorLike = typing.Union[numpy.ndarray[typing.Any, numpy.dty...y.ndar...
allow_new_attributes = <pyvista.core.utilities.state_manager._AllowNew...
global_config = PyVista Config
--------------
show_vtk_api ...
vtk_snake_case = <pyvista.core.utilities.state_manager._vtkSnakeCase o...
vtk_verbosity = <pyvista.core.utilities.state_manager._VTKVerbosity ob...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\__init__.py
pyvista.create_grid
Python Library Documentation: function create_grid in module pyvista.core.utilities.features
create_grid(dataset, dimensions=(101, 101, 101))
Create a uniform grid surrounding the given dataset.
The output grid will have the specified dimensions and is commonly used
for interpolating the input dataset.
Parameters
----------
dataset : DataSet
Input dataset used as a reference for the grid creation.
dimensions : tuple[int, int, int], default: (101, 101, 101)
The dimensions of the grid to be created. Each value in the tuple
represents the number of grid points along the corresponding axis.
Raises
------
NotImplementedError
If the dimensions parameter is set to None. Currently, the function
does not support automatically determining the "optimal" grid size
based on the sparsity of the points in the input dataset.
Returns
-------
ImageData
A uniform grid with the specified dimensions that surrounds the input
dataset.
pyvista.create_mixed_cells
Python Library Documentation: function create_mixed_cells in module pyvista.core.utilities.cells
create_mixed_cells(mixed_cell_dict: 'dict[np.uint8, NumpyArray[int]]', nr_points: 'int | None' = None) -> 'tuple[NumpyArray[np.uint8], NumpyArray[int]]'
Generate cell arrays for the creation of a pyvista.UnstructuredGrid from a cell dictionary.
This function generates all required cell arrays according to a given cell
dictionary. The given cell-dictionary should contain a proper
mapping of vtk_type -> np.ndarray (int), where the given ndarray
for each cell-type has to be an array of dimensions [N, D] or
[N*D], where N is the number of cells and D is the size of the
cells for the given type (e.g. 3 for triangles). Multiple
vtk_type keys with associated arrays can be present in one
dictionary. This function only accepts cell types of fixed size
and not dynamic sized cells like :attr:`~pyvista.CellType.POLYGON`
Parameters
----------
mixed_cell_dict : dict
A dictionary that maps VTK-Enum-types (e.g. :attr:`~pyvista.CellType.TRIANGLE`) to
np.ndarrays of type int. The ``np.ndarrays`` describe the cell
connectivity.
nr_points : int, optional
Number of points of the grid. Used only to allow additional runtime
checks for invalid indices.
Returns
-------
cell_types : numpy.ndarray (uint8)
Types of each cell.
cell_arr : numpy.ndarray (int)
VTK-cell array.
Raises
------
ValueError
If any of the cell types are not supported, have dynamic sized
cells, map to values with wrong size, or cell indices point
outside the given number of points.
Examples
--------
Create the cell arrays containing two triangles.
This will generate cell arrays to generate a mesh with two
disconnected triangles from 6 points.
>>> import numpy as np
>>> import vtk
>>> from pyvista.core.utilities.cells import create_mixed_cells
>>> cell_types, cell_arr = create_mixed_cells(
... {vtk.VTK_TRIANGLE: np.array([[0, 1, 2], [3, 4, 5]])}
... )
pyvista.dataobject
Python Library Documentation: module pyvista.core.dataobject in pyvista.core
NAME
pyvista.core.dataobject - Attributes common to PolyData and Grid Objects.
CLASSES
pyvista.core._vtk_utilities.DisableVtkSnakeCase(builtins.object)
DataObject(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride)
pyvista.core._vtk_utilities.vtkPyVistaOverride(builtins.object)
DataObject(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride)
pyvista.core.utilities.misc._NoNewAttrMixin(builtins.object)
DataObject(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride)
class DataObject(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride)
| DataObject(*args, **kwargs) -> '_T'
|
| Methods common to all wrapped data objects.
|
| Parameters
| ----------
| *args :
| Any extra args are passed as option to all wrapped data objects.
|
| **kwargs :
| Any extra keyword args are passed as option to all wrapped data objects.
|
| Method resolution order:
| DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| builtins.object
|
| Methods defined here:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __init__(self: 'Self', *args, **kwargs) -> 'None'
| Initialize the data object.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_meta_from(self: 'Self', *args, **kwargs) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Intended to be overridden by subclasses.
|
| Parameters
| ----------
| *args : tuple
| Positional arguments.
|
| **kwargs : dict, optional
| Keyword arguments.
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| get_data_range(self: 'Self', name: 'str | None', preference: 'FieldAssociation | str') -> 'tuple[float, float]'
| Get the non-NaN min and max of a named array.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| is_empty
| Return ``True`` if the object is empty.
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'get_data_range', 'is_empty'})
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
DATA
DEFAULT_VECTOR_KEY = '_vectors'
PICKLE_EXT = ('.pkl', '.pickle')
TYPE_CHECKING = False
USER_DICT_KEY = '_PYVISTA_USER_DICT'
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\dataobject.py
pyvista.dataset
Python Library Documentation: module pyvista.core.dataset in pyvista.core
NAME
pyvista.core.dataset - Attributes common to PolyData and Grid Objects.
CLASSES
builtins.tuple(builtins.object)
ActiveArrayInfoTuple
pyvista.core.dataobject.DataObject(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride)
DataSet(pyvista.core.filters.data_set.DataSetFilters, pyvista.core.dataobject.DataObject)
pyvista.core.filters.data_set.DataSetFilters(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.filters.data_object.DataObjectFilters)
DataSet(pyvista.core.filters.data_set.DataSetFilters, pyvista.core.dataobject.DataObject)
class ActiveArrayInfoTuple(builtins.tuple)
| ActiveArrayInfoTuple(association: ForwardRef('FieldAssociation'), name: ForwardRef('str | None'))
|
| Active array info tuple.
|
| Parameters
| ----------
| association : pyvista.core.utilities.arrays.FieldAssociation
| Association of the array.
|
| name : str
| The name of the array.
|
| Method resolution order:
| ActiveArrayInfoTuple
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.ActiveArrayInfoTuple
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.ActiveArrayInfoTuple
| Return a nicely formatted representation string
|
| _asdict(self) from collections.ActiveArrayInfoTuple
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.ActiveArrayInfoTuple
| Return a new ActiveArrayInfoTuple object replacing specified fields with new values
|
| copy(self: 'ActiveArrayInfoTuple') -> 'ActiveArrayInfoTuple'
| Return a copy of this object.
|
| Returns
| -------
| ActiveArrayInfo
| A copy of this object.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.ActiveArrayInfoTuple
| Make a new ActiveArrayInfoTuple object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, association: ForwardRef('FieldAssociation'), name: ForwardRef('str | None')) from namedtuple_ActiveArrayInfoTuple.ActiveArrayInfoTuple
| Create new instance of ActiveArrayInfoTuple(association, name)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| association
| Alias for field number 0
|
| name
| Alias for field number 1
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'association': ForwardRef('FieldAssociation'), 'nam...
|
| __match_args__ = ('association', 'name')
|
| __orig_bases__ = (<function NamedTuple>,)
|
| _field_defaults = {}
|
| _fields = ('association', 'name')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class DataSet(pyvista.core.filters.data_set.DataSetFilters, pyvista.core.dataobject.DataObject)
| DataSet(*args, **kwargs) -> '_T'
|
| Methods in common to spatially referenced objects.
|
| Parameters
| ----------
| *args :
| Any extra args are passed as option to spatially referenced objects.
|
| **kwargs :
| Any extra keyword args are passed as option to spatially referenced objects.
|
| Method resolution order:
| DataSet
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| builtins.object
|
| Methods defined here:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __init__(self: 'Self', *args, **kwargs) -> 'None'
| Initialize the common object.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| __repr__(self: 'Self') -> 'str'
| Return the object representation.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| __str__(self: 'Self') -> 'str'
| Return the object string representation.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
DATA
CellLiteral = typing.Literal[<FieldAssociation.CELL: 1>, 'cell']
DEFAULT_VECTOR_KEY = '_vectors'
FieldLiteral = typing.Literal[<FieldAssociation.NONE: 2>, 'field']
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
PointLiteral = typing.Literal[<FieldAssociation.POINT: 0>, 'point']
TYPE_CHECKING = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\dataset.py
pyvista.datasetattributes
Python Library Documentation: module pyvista.core.datasetattributes in pyvista.core
NAME
pyvista.core.datasetattributes - Implements DataSetAttributes, which represents and manipulates datasets.
CLASSES
pyvista.core._vtk_utilities.DisableVtkSnakeCase(builtins.object)
DataSetAttributes(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.VTKObjectWrapperCheckSnakeCase)
pyvista.core._vtk_utilities.VTKObjectWrapperCheckSnakeCase(vtkmodules.numpy_interface.dataset_adapter.VTKObjectWrapper)
DataSetAttributes(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.VTKObjectWrapperCheckSnakeCase)
pyvista.core.utilities.misc._NoNewAttrMixin(builtins.object)
DataSetAttributes(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.VTKObjectWrapperCheckSnakeCase)
class DataSetAttributes(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.VTKObjectWrapperCheckSnakeCase)
| DataSetAttributes(*args, **kwargs) -> '_T'
|
| Python friendly wrapper of :vtk:`vtkDataSetAttributes`.
|
| This class provides the ability to pick one of the present arrays as the
| currently active array for each attribute type by implementing a
| ``dict`` like interface.
|
| When adding data arrays but not desiring to set them as active
| scalars or vectors, use :func:`DataSetAttributes.set_array`.
|
| When adding directional data (such as velocity vectors), use
| :func:`DataSetAttributes.set_vectors`.
|
| When adding non-directional data (such as temperature values or
| multi-component scalars like RGBA values), use
| :func:`DataSetAttributes.set_scalars`.
|
| .. versionchanged:: 0.32.0
| The ``[]`` operator no longer allows integers. Use
| :func:`DataSetAttributes.get_array` to retrieve an array
| using an index.
|
| Parameters
| ----------
| vtkobject : :vtk:`vtkFieldData`
| The vtk object to wrap as a :class:~pyvista.DataSetAttribute`,
| usually an instance of :vtk:`vtkCellData`, :vtk:`vtkPointData`, or
| :vtk:`vtkFieldData`.
|
| dataset : :vtk:`vtkDataSet`
| The :vtk:`vtkDataSet` containing the vtkobject.
|
| association : FieldAssociation
| The array association type of the vtkobject.
|
| Notes
| -----
| When printing out the point arrays, you can see which arrays are
| the active scalars, vectors, normals, and texture coordinates.
| In the arrays list, ``SCALARS`` denotes that these are the active
| scalars, ``VECTORS`` denotes that these arrays are tagged as the
| active vectors data (i.e. data with magnitude and direction) and
| so on.
|
| Examples
| --------
| Store data with point association in a DataSet.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.point_data['my_data'] = range(mesh.n_points)
| >>> data = mesh.point_data['my_data']
| >>> data
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Change the data array and show that this is reflected in the DataSet.
|
| >>> data[:] = 0
| >>> mesh.point_data['my_data']
| pyvista_ndarray([0, 0, 0, 0, 0, 0, 0, 0])
|
| Remove the array.
|
| >>> del mesh.point_data['my_data']
| >>> 'my_data' in mesh.point_data
| False
|
| Print the available arrays from dataset attributes.
|
| >>> import numpy as np
| >>> mesh = pv.Plane(i_resolution=1, j_resolution=1)
| >>> mesh.point_data.set_array(range(4), 'my-data')
| >>> mesh.point_data.set_array(range(5, 9), 'my-other-data')
| >>> vectors0 = np.random.default_rng().random((4, 3))
| >>> mesh.point_data.set_vectors(vectors0, 'vectors0')
| >>> vectors1 = np.random.default_rng().random((4, 3))
| >>> mesh.point_data.set_vectors(vectors1, 'vectors1')
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : None
| Active Vectors : vectors1
| Active Texture : TextureCoordinates
| Active Normals : Normals
| Contains arrays :
| Normals float32 (4, 3) NORMALS
| TextureCoordinates float32 (4, 2) TCOORDS
| my-data int64 (4,)
| my-other-data int64 (4,)
| vectors1 float64 (4, 3) VECTORS
| vectors0 float64 (4, 3)
|
| Method resolution order:
| DataSetAttributes
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.VTKObjectWrapperCheckSnakeCase
| vtkmodules.numpy_interface.dataset_adapter.VTKObjectWrapper
| builtins.object
|
| Methods defined here:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export via the Arrow PyCapsule interface.
|
| Implements `the Arrow PyCapsule interface
| <https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html>`_
| so pandas, polars, DuckDB, ibis, narwhals, and other Arrow-aware
| consumers can ingest ``point_data`` / ``cell_data`` directly.
|
| Delegates to :meth:`to_arrow`, so the same memory-sharing rules
| apply: scalar 1D columns are zero-copy, multi-component expanded
| columns are copied.
|
| Requires :mod:`pyarrow`.
|
| __bool__(self: 'Self') -> 'bool'
| Return ``True`` when there are arrays present.
|
| __contains__(self: 'Self', name: 'str') -> 'bool'
| Implement the ``in`` operator.
|
| Uses VTK's native ``HasArray`` for an O(1) lookup, avoiding the
| cost of materialising every array name into a Python list. Falls
| back to ``self.keys()`` for the empty-name lookup so that
| ``keys()``'s legacy auto-rename side-effect (renaming any
| unnamed arrays to ``Unnamed_<i>``) still fires; some plotter
| codepaths (notably ``set_custom_opacity`` for array-valued
| ``opacity=`` arguments) inject anonymous arrays and rely on that
| side-effect to give them a unique, lookup-able name before
| downstream code activates them.
|
| __delitem__(self: 'Self', key: 'str') -> 'None'
| Implement del with array name or index.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test dict-like equivalency.
|
| __getitem__(self: 'Self', key: 'str') -> 'pyvista_ndarray'
| Implement ``[]`` operator.
|
| Accepts an array name.
|
| __init__(self: 'Self', vtkobject: '_vtk.vtkFieldData', dataset: '_vtk.vtkDataSet | DataSet', association: 'FieldAssociation') -> 'None'
| Initialize DataSetAttributes.
|
| __iter__(self: 'Self') -> 'Iterator[str]'
| Implement for loop iteration.
|
| __len__(self: 'Self') -> 'int'
| Return the number of arrays.
|
| __repr__(self: 'Self') -> 'str'
| Printable representation of DataSetAttributes.
|
| __setitem__(self: 'Self', key: 'str', value: 'ArrayLike[Any]') -> 'None'
| Implement setting with the ``[]`` operator.
|
| clear(self: 'Self') -> 'None'
| Remove all arrays in this object.
|
| Examples
| --------
| Add an array to ``point_data`` to a DataSet and then clear the
| point_data.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_data'] = range(mesh.n_points)
| >>> len(mesh.point_data)
| 1
| >>> mesh.point_data.clear()
| >>> len(mesh.point_data)
| 0
|
| get(self: 'Self', key: 'str', value: 'Any | None' = None) -> 'pyvista_ndarray | None'
| Return the value of the item with the specified key.
|
| Parameters
| ----------
| key : str
| Name of the array item you want to return the value from.
|
| value : Any, optional
| A value to return if the key does not exist. Default
| is ``None``.
|
| Returns
| -------
| Any
| Array if the ``key`` exists in the dataset, otherwise
| ``value``.
|
| Examples
| --------
| Show that the default return value for a non-existent key is
| ``None``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.point_data['my_data'] = range(mesh.n_points)
| >>> mesh.point_data.get('my-other-data')
|
| get_array(self: 'Self', key: 'str | int') -> 'pyvista_ndarray'
| Get an array in this object.
|
| Parameters
| ----------
| key : str | int
| The name or index of the array to return. Arrays are
| ordered within VTK DataSetAttributes, and this feature is
| mirrored here.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Returns a :class:`pyvista.pyvista_ndarray`.
|
| Raises
| ------
| KeyError
| If the key does not exist.
|
| Notes
| -----
| This is provided since arrays are ordered within VTK and can
| be indexed via an int. When getting an array, you can just
| use the key of the array with the ``[]`` operator with the
| name of the array.
|
| Examples
| --------
| Store data with point association in a DataSet.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_data'] = range(mesh.n_points)
|
| Access using an index.
|
| >>> mesh.point_data.get_array(0)
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Access using a key.
|
| >>> mesh.point_data.get_array('my_data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| items(self: 'Self') -> 'list[tuple[str, pyvista_ndarray]]'
| Return a list of (array name, array value) tuples.
|
| Returns
| -------
| list
| List of keys and values.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['data0'] = [0] * mesh.n_cells
| >>> mesh.cell_data['data1'] = range(mesh.n_cells)
| >>> mesh.cell_data.items() # doctest: +NORMALIZE_WHITESPACE
| [('data0', pyvista_ndarray([0, 0, 0, 0, 0, 0])),
| ('data1', pyvista_ndarray([0, 1, 2, 3, 4, 5]))]
|
| keys(self: 'Self') -> 'list[str]'
| Return the names of the arrays as a list.
|
| Returns
| -------
| list
| List of keys.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.clear_data()
| >>> mesh.point_data['data0'] = [0] * mesh.n_points
| >>> mesh.point_data['data1'] = range(mesh.n_points)
| >>> mesh.point_data.keys()
| ['data0', 'data1']
|
| pop(self: 'Self', key: 'str', default: 'pyvista_ndarray | T' = pyvista_ndarray([], dtype=float64)) -> 'pyvista_ndarray | T'
| Remove an array and return it.
|
| Parameters
| ----------
| key : str
| The name of the array to remove and return.
|
| default : Any, optional
| If default is not given and key is not in the dictionary,
| a KeyError is raised.
|
| Returns
| -------
| pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Add a point data array to a DataSet and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.point_data['my_data'] = range(mesh.n_points)
| >>> mesh.point_data.pop('my_data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Show that the array no longer exists in ``point_data``.
|
| >>> 'my_data' in mesh.point_data
| False
|
| remove(self: 'Self', key: 'str') -> 'None'
| Remove an array.
|
| Parameters
| ----------
| key : str
| The name of the array to remove.
|
| Notes
| -----
| You can also use the ``del`` statement.
|
| Examples
| --------
| Add a point data array to a DataSet and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.point_data['my_data'] = range(mesh.n_points)
| >>> mesh.point_data.remove('my_data')
|
| Show that the array no longer exists in ``point_data``.
|
| >>> 'my_data' in mesh.point_data
| False
|
| set_array(self: 'Self', data: 'ArrayLike[float]', name: 'str', deep_copy: 'bool' = False) -> 'None'
| Add an array to this object.
|
| Use this method when adding arrays to the DataSet. If
| needed, these arrays can later be assigned to become the
| active scalars, vectors, normals, or texture coordinates with:
|
| * :attr:`active_scalars_name`
| * :attr:`active_vectors_name`
| * :attr:`active_normals_name`
| * :attr:`active_texture_coordinates_name`
|
| Parameters
| ----------
| data : ArrayLike[float]
| Array of data.
|
| name : str
| Name to assign to the data. If this name already exists,
| it will be overwritten.
|
| deep_copy : bool, optional
| When ``True`` makes a full copy of the array.
|
| Notes
| -----
| You can simply use the ``[]`` operator to add an array to the
| dataset. Note that this will automatically become the active
| scalars.
|
| Examples
| --------
| Add a point array to a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> data = range(mesh.n_points)
| >>> mesh.point_data.set_array(data, 'my-data')
| >>> mesh.point_data['my-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Add a cell array to a mesh.
|
| >>> cell_data = range(mesh.n_cells)
| >>> mesh.cell_data.set_array(cell_data, 'my-data')
| >>> mesh.cell_data['my-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Add field data to a mesh.
|
| >>> field_data = range(3)
| >>> mesh.field_data.set_array(field_data, 'my-data')
| >>> mesh.field_data['my-data']
| pyvista_ndarray([0, 1, 2])
|
| set_scalars(self: 'Self', scalars: 'ArrayLike[float]', name: 'str' = 'scalars', deep_copy: 'bool' = False) -> 'None'
| Set the active scalars of the dataset with an array.
|
| In VTK and PyVista, scalars are a quantity that has no
| direction. This can include data with multiple components
| (such as RGBA values) or just one component (such as
| temperature data).
|
| See :func:`DataSetAttributes.set_vectors` when adding arrays
| that contain magnitude and direction.
|
| Parameters
| ----------
| scalars : ArrayLike[float]
| Array of data.
|
| name : str, default: 'scalars'
| Name to assign the scalars.
|
| deep_copy : bool, default: False
| When ``True`` makes a full copy of the array.
|
| Notes
| -----
| When adding directional data (such as velocity vectors), use
| :func:`DataSetAttributes.set_vectors`.
|
| Complex arrays will be represented internally as a 2 component float64
| array. This is due to limitations of VTK's native datatypes.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> scalars = range(mesh.n_points)
| >>> mesh.point_data.set_scalars(scalars, 'my-scalars')
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my-scalars
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my-scalars int64 (8,) SCALARS
|
| set_vectors(self: 'Self', vectors: 'MatrixLike[float]', name: 'str', deep_copy: 'bool' = False) -> 'None'
| Set the active vectors of this data attribute.
|
| Vectors are a quantity that has magnitude and direction, such
| as normal vectors or a velocity field.
|
| The vectors data must contain three components per cell or point. Use
| :func:`DataSetAttributes.set_scalars` when adding non-directional data.
|
| Parameters
| ----------
| vectors : MatrixLike
| Data shaped ``(n, 3)`` where n matches the number of points or cells.
|
| name : str
| Name of the vectors.
|
| deep_copy : bool, default: False
| When ``True`` makes a full copy of the array. When ``False``, the
| data references the original array without copying it.
|
| Notes
| -----
| PyVista and VTK treats vectors and scalars differently when performing
| operations. Vector data, unlike scalar data, is rotated along with the
| geometry when the DataSet is passed through a transformation filter.
|
| When adding non-directional data (such temperature values or
| multi-component scalars like RGBA values), you can also use
| :func:`DataSetAttributes.set_scalars`.
|
| Examples
| --------
| Add random vectors to a mesh as point data.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> vectors = np.random.default_rng().random((mesh.n_points, 3))
| >>> mesh.point_data.set_vectors(vectors, 'my-vectors')
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : None
| Active Vectors : my-vectors
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my-vectors float64 (8, 3) VECTORS
|
| to_arrow(self: 'Self') -> 'pyarrow.Table'
| Return this attribute set as a :class:`pyarrow.Table`.
|
| Each array becomes a column. Multi-component arrays (e.g. a
| ``(N, 3)`` vector field) are expanded to one column per component,
| named ``{array_name}_{i}``. Only ``point_data`` and ``cell_data``
| can be converted. ``field_data`` raises :class:`ValueError`
| because its arrays may have differing lengths.
|
| Requires :mod:`pyarrow`.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array and
| :attr:`valid_array_len` rows.
|
| Notes
| -----
| Memory sharing with the underlying VTK buffers is mixed:
|
| - 1D contiguous numeric columns (scalar arrays) wrap the VTK
| buffer zero-copy. The Arrow column and the VTK array point at
| the same memory.
| - Expanded multi-component columns (``{name}_{i}``) come from
| strided slices and are copied into contiguous buffers.
| - Booleans, complex numbers, and strings go through pyvista's
| existing VTK conversion and are copied.
|
| Arrow buffers are immutable by contract, so consumers cannot
| mutate VTK memory through the returned table.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> table = mesh.point_data.to_arrow()
| >>> table.num_rows
| 8
|
| to_pandas(self: 'Self') -> 'pandas.DataFrame'
| Return this attribute set as a :class:`pandas.DataFrame`.
|
| Each array becomes a column. Multi-component arrays are expanded
| to one column per component, named ``{array_name}_{i}``. Only
| ``point_data`` and ``cell_data`` can be converted.
| ``field_data`` raises :class:`ValueError`.
|
| Requires :mod:`pandas`.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array and
| :attr:`valid_array_len` rows.
|
| Notes
| -----
| Pandas consolidates the dict of columns into internal blocks
| during construction, which copies the data. The returned
| DataFrame is effectively a snapshot and does not share memory
| with VTK. Callers that need zero-copy access should use
| :meth:`to_arrow` instead.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.point_data.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| update(self: 'Self', array_dict: 'dict[str, NumpyArray[float]] | DataSetAttributes', copy: 'bool' = True) -> 'None'
| Update arrays in this object from another dictionary or dataset attributes.
|
| For each key, value given, add the pair. If it already exists, replace
| it with the new array. These arrays will be copied.
|
| Parameters
| ----------
| array_dict : dict, DataSetAttributes
| A dictionary of ``(array name, :class:`numpy.ndarray`)`` or a
| :class:`pyvista.DataSetAttributes`.
|
| copy : bool, default: True
| If ``True``, arrays from ``array_dict`` are copied to this object.
|
| Examples
| --------
| Add two arrays to ``point_data`` using ``update``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> n = len(mesh.point_data)
| >>> arrays = {
| ... 'foo': np.arange(mesh.n_points),
| ... 'rand': np.random.default_rng().random(mesh.n_points),
| ... }
| >>> mesh.point_data.update(arrays)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| foo int64 (1000,)
| rand float64 (1000,)
|
| values(self: 'Self') -> 'list[pyvista_ndarray]'
| Return the arrays as a list.
|
| Returns
| -------
| list
| List of arrays.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['data0'] = [0] * mesh.n_cells
| >>> mesh.cell_data['data1'] = range(mesh.n_cells)
| >>> mesh.cell_data.values()
| [pyvista_ndarray([0, 0, 0, 0, 0, 0]), pyvista_ndarray([0, 1, 2, 3, 4, 5])]
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| active_scalars
| Return the active scalars.
|
| .. versionchanged:: 0.32.0
| Can no longer be used to set the active scalars. Either use
| :func:`DataSetAttributes.set_scalars` or if the array
| already exists, assign to
| :attr:`pyvista.DataSetAttributes.active_scalars_name`.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars.
|
| Examples
| --------
| Associate point data to a simple cube mesh and show that the
| active scalars in the point array are the most recently added
| array.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.point_data['data0'] = np.arange(mesh.n_points)
| >>> mesh.point_data.active_scalars
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| active_vectors
| Return the active vectors as a pyvista_ndarray.
|
| .. versionchanged:: 0.32.0
| Can no longer be used to set the active vectors. Either use
| :func:`DataSetAttributes.set_vectors` or if the array
| already exists, assign to
| :attr:`pyvista.DataSetAttributes.active_vectors_name`.
|
| Returns
| -------
| Optional[np.ndarray]
| Active vectors as a pyvista_ndarray.
|
| Examples
| --------
| Associate point data to a simple cube mesh and show that the
| active vectors in the point array are the most recently added
| array.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> vectors = np.random.default_rng().random((mesh.n_points, 3))
| >>> mesh.point_data.set_vectors(vectors, 'my-vectors')
| >>> vectors_out = mesh.point_data.active_vectors
| >>> vectors_out.shape
| (8, 3)
|
| valid_array_len
| Return the length data should be when added to the dataset.
|
| If there are no restrictions, returns ``None``.
|
| Returns
| -------
| Optional[int]
| Length data should be when added to the dataset.
|
| Examples
| --------
| Show that valid array lengths match the number of points and
| cells for point and cell arrays, and there is no length limit
| for field data.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.n_points, mesh.n_cells
| (8, 6)
| >>> mesh.point_data.valid_array_len
| 8
| >>> mesh.cell_data.valid_array_len
| 6
| >>> mesh.field_data.valid_array_len is None
| True
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| active_normals
| Return the normals.
|
| Returns
| -------
| pyvista_ndarray
| Normals of this dataset attribute. ``None`` if no normals have been
| set.
|
| Notes
| -----
| Field data will have no normals.
|
| Examples
| --------
| First, compute cell normals.
|
| >>> import pyvista as pv
| >>> mesh = pv.Plane(i_resolution=1, j_resolution=1)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : None
| Active Vectors : None
| Active Texture : TextureCoordinates
| Active Normals : Normals
| Contains arrays :
| Normals float32 (4, 3) NORMALS
| TextureCoordinates float32 (4, 2) TCOORDS
|
| >>> mesh.point_data.active_normals
| pyvista_ndarray([[0., 0., 1.],
| [0., 0., 1.],
| [0., 0., 1.],
| [0., 0., 1.]], dtype=float32)
|
| Assign normals to the cell arrays. An array will be added
| named ``"Normals"``.
|
| >>> mesh.cell_data.active_normals = [[0.0, 0.0, 1.0]]
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : Normals
| Contains arrays :
| Normals float64 (1, 3) NORMALS
|
| active_normals_name
| Return the name of the normals array.
|
| Returns
| -------
| str
| Name of the active normals array.
|
| Examples
| --------
| First, compute cell normals.
|
| >>> import pyvista as pv
| >>> mesh = pv.Plane(i_resolution=1, j_resolution=1)
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.point_data.active_normals_name
| 'Normals'
|
| active_scalars_name
| Return name of the active scalars.
|
| Returns
| -------
| Optional[str]
| Name of the active scalars.
|
| Examples
| --------
| Add two arrays to the mesh point data. Note how the first array becomes
| the active scalars since the ``mesh`` contained no scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_data'] = range(mesh.n_points)
| >>> mesh.point_data['my_other_data'] = range(mesh.n_points)
| >>> mesh.point_data.active_scalars_name
| 'my_data'
|
| Set the name of the active scalars.
|
| >>> mesh.point_data.active_scalars_name = 'my_other_data'
| >>> mesh.point_data.active_scalars_name
| 'my_other_data'
|
| active_texture_coordinates
| Return the active texture coordinates array.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Array of the active texture coordinates.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.point_data.active_texture_coordinates
| pyvista_ndarray([[-0., 0.],
| [ 0., 0.],
| [ 0., 1.],
| [-0., 1.],
| [-1., 0.],
| [-1., 1.],
| [ 1., 1.],
| [ 1., 0.]], dtype=float32)
|
| active_texture_coordinates_name
| Return the name of the active texture coordinates array.
|
| Returns
| -------
| Optional[str]
| Name of the active texture coordinates array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.point_data.active_texture_coordinates_name
| 'TCoords'
|
| active_vectors_name
| Return name of the active vectors.
|
| Returns
| -------
| Optional[str]
| Name of the active vectors.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.set_vectors(
| ... np.random.default_rng().random((mesh.n_points, 3)),
| ... 'my-vectors',
| ... )
| >>> mesh.point_data.active_vectors_name
| 'my-vectors'
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.VTKObjectWrapperCheckSnakeCase:
|
| __getattr__(self, name: 'str')
| Forward unknown attribute requests to VTKArray's __getattr__.
DATA
T = ~T
TYPE_CHECKING = False
attr_type = ['SCALARS', 'VECTORS', 'NORMALS', 'TCOORDS', 'TENSORS', 'G...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\datasetattributes.py
pyvista.enable_smp_tools
Python Library Documentation: function enable_smp_tools in module pyvista.core.utilities.misc
enable_smp_tools(backend: '_SMPBackendOptions' = 'stdthread', n_threads: 'int | None' = None) -> '_SMPToolsContext'
Enable a VTK SMP backend for filters that support shared-memory parallelism.
VTK's Python wheels currently default to the sequential SMP backend. This
helper switches to a parallel backend and optionally configures the maximum
number of threads used by VTK filters that rely on :vtk:`vtkSMPTools`.
The backend is applied immediately, so calling this function by itself
enables the chosen backend for the rest of the process. The return value is
also a context manager, so using it with a ``with`` statement will restore
the previous backend and thread count on exit.
Parameters
----------
backend : str, default: 'stdthread'
SMP backend to enable. Acceptable values are:
- ``'stdthread'``: Enable VTK's ``std::thread`` backend. This is the
default and is available in the current VTK wheels.
- ``'tbb'``: Enable Intel oneTBB when available in the current VTK
build.
- ``'openmp'``: Enable OpenMP when available in the current VTK build.
- ``'sequential'``: Use VTK's sequential backend.
n_threads : int, optional
Maximum number of threads to use. If not provided, VTK resets to its
default maximum thread count and honors the ``VTK_SMP_MAX_THREADS``
environment variable when it is set.
Returns
-------
contextlib.AbstractContextManager
A context manager that restores the previous SMP backend and thread
count when exited. The return value may be discarded when the change
should apply for the remainder of the process.
Raises
------
TypeError
If ``backend`` is not a string or if ``n_threads`` is not an integer.
ValueError
If ``backend`` is invalid or if ``n_threads`` is less than ``1``.
RuntimeError
If this VTK build does not support runtime SMP backend selection, or if
the requested backend is unavailable.
Examples
--------
Enable the wheel-supported ``stdthread`` backend for the rest of the
process.
>>> import pyvista as pv
>>> pv.enable_smp_tools() # doctest:+SKIP
Configure the backend before running a contour filter.
>>> from pyvista import examples
>>> pv.enable_smp_tools(n_threads=8) # doctest:+SKIP
>>> grid = examples.download_fea_bracket() # doctest:+SKIP
>>> _ = grid.contour(5, scalars='Equivalent Stress') # doctest:+SKIP
Scope the backend change to a ``with`` block. The previous backend and
thread count are restored on exit, even if an exception is raised.
>>> with pv.enable_smp_tools(n_threads=8): # doctest:+SKIP
... _ = grid.contour(5, scalars='Equivalent Stress')
pyvista.errors
Python Library Documentation: module pyvista.core.errors in pyvista.core
NAME
pyvista.core.errors - PyVista specific errors.
CLASSES
builtins.AttributeError(builtins.Exception)
PyVistaAttributeError
builtins.RuntimeError(builtins.Exception)
DeprecationError
PyVistaPipelineError
VTKExecutionError
VTKVersionError
builtins.RuntimeWarning(builtins.Warning)
VTKExecutionWarning
builtins.TypeError(builtins.Exception)
PartitionedDataSetsNotSupported
PointSetNotSupported
PointSetCellOperationError
PointSetDimensionReductionError
builtins.ValueError(builtins.Exception)
AmbiguousDataError
CellSizeError
InvalidMeshError
MissingDataError
NotAllTrianglesError
builtins.Warning(builtins.Exception)
InvalidMeshWarning
PyVistaDeprecationWarning
PyVistaEfficiencyWarning
PyVistaFutureWarning
class AmbiguousDataError(builtins.ValueError)
| AmbiguousDataError(message='Multiple data available.') -> 'None'
|
| Exception when data is ambiguous, e.g. multiple active scalars can be set.
|
| Parameters
| ----------
| message : str
| Error message.
|
| Method resolution order:
| AmbiguousDataError
| builtins.ValueError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message='Multiple data available.') -> 'None'
| Call the base class constructor with the custom message.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.ValueError:
|
| __new__(*args, **kwargs) class method of builtins.ValueError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class CellSizeError(builtins.ValueError)
| CellSizeError(message='Cell array size is invalid.') -> 'None'
|
| Exception when a cell array size is invalid.
|
| Parameters
| ----------
| message : str
| Error message.
|
| Method resolution order:
| CellSizeError
| builtins.ValueError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message='Cell array size is invalid.') -> 'None'
| Call the base class constructor with the custom message.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.ValueError:
|
| __new__(*args, **kwargs) class method of builtins.ValueError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class DeprecationError(builtins.RuntimeError)
| DeprecationError(message='This feature has been deprecated') -> 'None'
|
| Used for deprecated methods and functions.
|
| Parameters
| ----------
| message : str
| Error message.
|
| Method resolution order:
| DeprecationError
| builtins.RuntimeError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message='This feature has been deprecated') -> 'None'
| Empty init.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.RuntimeError:
|
| __new__(*args, **kwargs) class method of builtins.RuntimeError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class InvalidMeshError(builtins.ValueError)
| InvalidMeshError(message='Invalid mesh.') -> 'None'
|
| Error for invalid mesh properties.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| message : str
| Error message.
|
| Method resolution order:
| InvalidMeshError
| builtins.ValueError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message='Invalid mesh.') -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.ValueError:
|
| __new__(*args, **kwargs) class method of builtins.ValueError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class InvalidMeshWarning(builtins.Warning)
| Warning for invalid mesh properties.
|
| .. versionadded:: 0.47
|
| Method resolution order:
| InvalidMeshWarning
| builtins.Warning
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Warning:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Warning:
|
| __new__(*args, **kwargs) class method of builtins.Warning
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class MissingDataError(builtins.ValueError)
| MissingDataError(message='No data available.') -> 'None'
|
| Exception when data is missing, e.g. no active scalars can be set.
|
| Parameters
| ----------
| message : str
| Error message.
|
| Method resolution order:
| MissingDataError
| builtins.ValueError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message='No data available.') -> 'None'
| Call the base class constructor with the custom message.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.ValueError:
|
| __new__(*args, **kwargs) class method of builtins.ValueError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class NotAllTrianglesError(builtins.ValueError)
| NotAllTrianglesError(message='Mesh must consist of only triangles') -> 'None'
|
| Exception when a mesh does not contain all triangles.
|
| Parameters
| ----------
| message : str
| Error message.
|
| Method resolution order:
| NotAllTrianglesError
| builtins.ValueError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message='Mesh must consist of only triangles') -> 'None'
| Empty init.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.ValueError:
|
| __new__(*args, **kwargs) class method of builtins.ValueError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class PartitionedDataSetsNotSupported(builtins.TypeError)
| PartitionedDataSetsNotSupported(message='The requested operation is not supported for PartitionedDataSetss.') -> 'None'
|
| Requested filter or property is not supported by the PartitionedDataSets class.
|
| Parameters
| ----------
| message : str
| Error message.
|
| Method resolution order:
| PartitionedDataSetsNotSupported
| builtins.TypeError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message='The requested operation is not supported for PartitionedDataSetss.') -> 'None'
| Empty init.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.TypeError:
|
| __new__(*args, **kwargs) class method of builtins.TypeError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class PointSetCellOperationError(PointSetNotSupported)
| PointSetCellOperationError(message='Cell operations are not supported. PointSets contain no cells.') -> 'None'
|
| Requested filter or property is not supported by the PointSet class.
|
| Parameters
| ----------
| message : str
| Error message.
|
| Method resolution order:
| PointSetCellOperationError
| PointSetNotSupported
| builtins.TypeError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message='Cell operations are not supported. PointSets contain no cells.') -> 'None'
| Empty init.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from PointSetNotSupported:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.TypeError:
|
| __new__(*args, **kwargs) class method of builtins.TypeError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class PointSetDimensionReductionError(PointSetNotSupported)
| PointSetDimensionReductionError(message='Slice and other dimension reducing filters are not supported on PointSets.') -> 'None'
|
| Requested filter or property is not supported by the PointSet class.
|
| Parameters
| ----------
| message : str
| Error message.
|
| Method resolution order:
| PointSetDimensionReductionError
| PointSetNotSupported
| builtins.TypeError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message='Slice and other dimension reducing filters are not supported on PointSets.') -> 'None'
| Empty init.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from PointSetNotSupported:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.TypeError:
|
| __new__(*args, **kwargs) class method of builtins.TypeError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class PointSetNotSupported(builtins.TypeError)
| PointSetNotSupported(message='The requested operation is not supported for PointSets.') -> 'None'
|
| Requested filter or property is not supported by the PointSet class.
|
| Parameters
| ----------
| message : str
| Error message.
|
| Method resolution order:
| PointSetNotSupported
| builtins.TypeError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message='The requested operation is not supported for PointSets.') -> 'None'
| Empty init.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.TypeError:
|
| __new__(*args, **kwargs) class method of builtins.TypeError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class PyVistaAttributeError(builtins.AttributeError)
| PyVistaAttributeError(message='The attribute is not part of the PyVista API') -> 'None'
|
| Exception when accessing an attribute that is not part of the PyVista API.
|
| Parameters
| ----------
| message : str
| Error message.
|
| Method resolution order:
| PyVistaAttributeError
| builtins.AttributeError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message='The attribute is not part of the PyVista API') -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.AttributeError:
|
| __getstate__(...)
| Helper for pickle.
|
| __reduce__(...)
| Helper for pickle.
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.AttributeError:
|
| name
| attribute name
|
| obj
| object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class PyVistaDeprecationWarning(builtins.Warning)
| Non-supressed Deprecation Warning.
|
| Method resolution order:
| PyVistaDeprecationWarning
| builtins.Warning
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Warning:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Warning:
|
| __new__(*args, **kwargs) class method of builtins.Warning
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class PyVistaEfficiencyWarning(builtins.Warning)
| Efficiency warning.
|
| Method resolution order:
| PyVistaEfficiencyWarning
| builtins.Warning
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Warning:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Warning:
|
| __new__(*args, **kwargs) class method of builtins.Warning
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class PyVistaFutureWarning(builtins.Warning)
| Non-supressed Future Warning.
|
| Method resolution order:
| PyVistaFutureWarning
| builtins.Warning
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Warning:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Warning:
|
| __new__(*args, **kwargs) class method of builtins.Warning
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class PyVistaPipelineError(builtins.RuntimeError)
| PyVistaPipelineError(message='VTK pipeline issue detected by PyVista.') -> 'None'
|
| Exception when a VTK pipeline runs into an issue.
|
| Parameters
| ----------
| message : str
| Error message.
|
| Method resolution order:
| PyVistaPipelineError
| builtins.RuntimeError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message='VTK pipeline issue detected by PyVista.') -> 'None'
| Call the base class constructor with the custom message.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.RuntimeError:
|
| __new__(*args, **kwargs) class method of builtins.RuntimeError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class VTKExecutionError(builtins.RuntimeError)
| VTKExecutionError(message='VTK output message was detected by PyVista.') -> 'None'
|
| Exception when a VTK output message is detected.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| message : str
| Error message.
|
| Method resolution order:
| VTKExecutionError
| builtins.RuntimeError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message='VTK output message was detected by PyVista.') -> 'None'
| Call the base class constructor with the custom message.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.RuntimeError:
|
| __new__(*args, **kwargs) class method of builtins.RuntimeError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class VTKExecutionWarning(builtins.RuntimeWarning)
| Warning when a VTK output message is detected.
|
| .. versionadded:: 0.47
|
| Method resolution order:
| VTKExecutionWarning
| builtins.RuntimeWarning
| builtins.Warning
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.RuntimeWarning:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.RuntimeWarning:
|
| __new__(*args, **kwargs) class method of builtins.RuntimeWarning
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class VTKVersionError(builtins.RuntimeError)
| VTKVersionError(message='The requested feature is not supported by the installed VTK version.') -> 'None'
|
| Requested feature is not supported by the installed VTK version.
|
| Parameters
| ----------
| message : str
| Error message.
|
| Method resolution order:
| VTKVersionError
| builtins.RuntimeError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message='The requested feature is not supported by the installed VTK version.') -> 'None'
| Empty init.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.RuntimeError:
|
| __new__(*args, **kwargs) class method of builtins.RuntimeError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\errors.py
pyvista.features
Python Library Documentation: module pyvista.core.utilities.features in pyvista.core.utilities
NAME
pyvista.core.utilities.features - Module containing geometry helper functions.
FUNCTIONS
cartesian_to_spherical(x, y, z)
Convert 3D Cartesian coordinates to spherical coordinates.
Parameters
----------
x, y, z : numpy.ndarray
Cartesian coordinates.
Returns
-------
r : numpy.ndarray
Radial distance.
phi : numpy.ndarray
Angle (radians) with respect to the polar axis. Also known
as polar angle.
theta : numpy.ndarray
Angle (radians) of rotation from the initial meridian plane.
Also known as azimuthal angle.
Examples
--------
>>> import numpy as np
>>> import pyvista as pv
>>> grid = pv.ImageData(dimensions=(3, 3, 3))
>>> x, y, z = grid.points.T
>>> r, phi, theta = pv.cartesian_to_spherical(x, y, z)
create_grid(dataset, dimensions=(101, 101, 101))
Create a uniform grid surrounding the given dataset.
The output grid will have the specified dimensions and is commonly used
for interpolating the input dataset.
Parameters
----------
dataset : DataSet
Input dataset used as a reference for the grid creation.
dimensions : tuple[int, int, int], default: (101, 101, 101)
The dimensions of the grid to be created. Each value in the tuple
represents the number of grid points along the corresponding axis.
Raises
------
NotImplementedError
If the dimensions parameter is set to None. Currently, the function
does not support automatically determining the "optimal" grid size
based on the sparsity of the points in the input dataset.
Returns
-------
ImageData
A uniform grid with the specified dimensions that surrounds the input
dataset.
grid_from_sph_coords(theta, phi, r)
Create a structured grid from arrays of spherical coordinates.
Parameters
----------
theta : array_like[float]
Azimuthal angle in degrees ``[0, 360]``.
phi : array_like[float]
Polar (zenith) angle in degrees ``[0, 180]``.
r : array_like[float]
Distance (radius) from the point of origin.
Returns
-------
pyvista.StructuredGrid
Structured grid.
See Also
--------
:ref:`spherical_example`
merge(datasets, merge_points: 'bool' = True, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
Merge several datasets.
.. note::
The behavior of this filter varies from the
:func:`PolyDataFilters.boolean_union` filter. This filter
does not attempt to create a manifold mesh and will include
internal surfaces when two meshes overlap.
.. warning::
The merge order of this filter depends on the installed version
of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
This may be a breaking change for some applications. If only
merging two meshes, it may be possible to maintain `some` backwards
compatibility by swapping the input order of the two meshes,
though this may also affect the merged arrays and is therefore
not fully backwards-compatible.
Parameters
----------
datasets : sequence[:class:`pyvista.DataSet`]
Sequence of datasets. Can be of any :class:`pyvista.DataSet`.
merge_points : bool, default: True
Merge equivalent points when ``True``.
main_has_priority : bool, default: True
When this parameter is ``True`` and ``merge_points=True``, the arrays
of the merging grids will be overwritten by the original main mesh.
.. deprecated:: 0.46
This keyword will be removed in a future version. The main mesh
always has priority with VTK 9.5.0 or later.
progress_bar : bool, default: False
Display a progress bar to indicate progress.
Returns
-------
pyvista.DataSet
:class:`pyvista.PolyData` if all items in datasets are
:class:`pyvista.PolyData`, otherwise returns a
:class:`pyvista.UnstructuredGrid`.
Examples
--------
Merge two polydata datasets.
>>> import pyvista as pv
>>> sphere = pv.Sphere(center=(0, 0, 1))
>>> cube = pv.Cube()
>>> mesh = pv.merge([cube, sphere])
>>> mesh.plot()
perlin_noise(amplitude, freq: 'Sequence[float]', phase: 'Sequence[float]')
Return the implicit function that implements Perlin noise.
Uses :vtk:`vtkPerlinNoise` and computes a Perlin noise field as
an implicit function. :vtk:`vtkPerlinNoise` is a concrete
implementation of :vtk:`vtkImplicitFunction`. Perlin noise,
originally described by Ken Perlin, is a non-periodic and
continuous noise function useful for modeling real-world objects.
The amplitude and frequency of the noise pattern are
adjustable. This implementation of Perlin noise is derived closely
from Greg Ward's version in Graphics Gems II.
Parameters
----------
amplitude : float
Amplitude of the noise function.
``amplitude`` can be negative. The noise function varies
randomly between ``-|Amplitude|`` and
``|Amplitude|``. Therefore the range of values is
``2*|Amplitude|`` large. The initial amplitude is 1.
freq : sequence[float]
The frequency, or physical scale, of the noise function
(higher is finer scale).
The frequency can be adjusted per axis, or the same for all axes.
phase : sequence[float]
Set/get the phase of the noise function.
This parameter can be used to shift the noise function within
space (perhaps to avoid a beat with a noise pattern at another
scale). Phase tends to repeat about every unit, so a phase of
0.5 is a half-cycle shift.
Returns
-------
:vtk:`vtkPerlinNoise`
Instance of :vtk:`vtkPerlinNoise` to a Perlin noise field as an
implicit function. Use with :func:`~pyvista.sample_function`.
See Also
--------
:ref:`perlin_noise_2d_example`
:ref:`perlin_noise_3d_example`
Examples
--------
Create a Perlin noise function with an amplitude of 0.1, frequency
for all axes of 1, and a phase of 0 for all axes.
>>> import pyvista as pv
>>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
Sample Perlin noise over a structured grid and plot it.
>>> grid = pv.sample_function(noise, bounds=[0, 5, 0, 5, 0, 5])
>>> grid.plot()
sample_function(function: '_vtk.vtkImplicitFunction', bounds: 'Sequence[float]' = (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0), dim: 'Sequence[int]' = (50, 50, 50), compute_normals: 'bool' = False, output_type: 'np.dtype' = <class 'numpy.float64'>, capping: 'bool' = False, cap_value: 'float' = 1.7976931348623157e+308, scalar_arr_name: 'str' = 'scalars', normal_arr_name: 'str' = 'normals', progress_bar: 'bool' = False)
Sample an implicit function over a structured point set.
Uses :vtk:`vtkSampleFunction`
This method evaluates an implicit function and normals at each
point in a :vtk:`vtkStructuredPoints`. The user can specify the
sample dimensions and location in space to perform the sampling.
To create closed surfaces (in conjunction with the
:vtk:`vtkContourFilter`), capping can be turned on to set a particular
value on the boundaries of the sample space.
Parameters
----------
function : :vtk:`vtkImplicitFunction`
Implicit function to evaluate. For example, the function
generated from :func:`perlin_noise() <pyvista.core.utilities.features.perlin_noise>`.
bounds : sequence[float], default: (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0)
Specify the bounds in the format of:
- ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
dim : sequence[float], default: (50, 50, 50)
Dimensions of the data on which to sample in the format of
``(xdim, ydim, zdim)``.
compute_normals : bool, default: False
Enable or disable the computation of normals.
output_type : numpy.dtype, default: numpy.double
Set the output scalar type. One of the following:
- ``np.float64``
- ``np.float32``
- ``np.int64``
- ``np.uint64``
- ``np.int32``
- ``np.uint32``
- ``np.int16``
- ``np.uint16``
- ``np.int8``
- ``np.uint8``
capping : bool, default: False
Enable or disable capping. If capping is enabled, then the outer
boundaries of the structured point set are set to cap value. This can
be used to ensure surfaces are closed.
cap_value : float, default: sys.float_info.max
Capping value used with the ``capping`` parameter.
scalar_arr_name : str, default: "scalars"
Set the scalar array name for this data set.
normal_arr_name : str, default: "normals"
Set the normal array name for this data set.
progress_bar : bool, default: False
Display a progress bar to indicate progress.
Returns
-------
pyvista.ImageData
Uniform grid with sampled data.
Examples
--------
Sample Perlin noise over a structured grid in 3D.
>>> import pyvista as pv
>>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
>>> grid = pv.sample_function(
... noise, bounds=[0, 3.0, -0, 1.0, 0, 1.0], dim=(60, 20, 20)
... )
>>> grid.plot(cmap='gist_earth_r', show_scalar_bar=False, show_edges=True)
Sample Perlin noise in 2D and plot it.
>>> noise = pv.perlin_noise(0.1, (5, 5, 5), (0, 0, 0))
>>> surf = pv.sample_function(noise, dim=(200, 200, 1))
>>> surf.plot()
See :ref:`perlin_noise_2d_example` and :ref:`perlin_noise_3d_example`
for a full example using this function.
spherical_to_cartesian(r, phi, theta)
Convert Spherical coordinates to 3D Cartesian coordinates.
Parameters
----------
r : numpy.ndarray
Radial distance.
phi : numpy.ndarray
Angle (radians) with respect to the polar axis. Also known
as polar angle.
theta : numpy.ndarray
Angle (radians) of rotation from the initial meridian plane.
Also known as azimuthal angle.
Returns
-------
output : numpy.ndarray, numpy.ndarray, numpy.ndarray
Cartesian coordinates.
transform_vectors_sph_to_cart(theta, phi, r, u, v, w)
Transform vectors from spherical (r, phi, theta) to cartesian coordinates (z, y, x).
Note the "reverse" order of arrays's axes, commonly used in geosciences.
Parameters
----------
theta : array_like[float]
Azimuthal angle in degrees ``[0, 360]`` of shape ``(M,)``.
phi : array_like[float]
Polar (zenith) angle in degrees ``[0, 180]`` of shape ``(N,)``.
r : array_like[float]
Distance (radius) from the point of origin of shape ``(P,)``.
u : array_like[float]
X-component of the vector of shape ``(P, N, M)``.
v : array_like[float]
Y-component of the vector of shape ``(P, N, M)``.
w : array_like[float]
Z-component of the vector of shape ``(P, N, M)``.
Returns
-------
u_t, v_t, w_t : :class:`numpy.ndarray`
Arrays of transformed x-, y-, z-components, respectively.
voxelize(mesh, density=None, check_surface: 'bool' = True, enclosed: 'bool' = False, fit_bounds: 'bool' = False)
Voxelize mesh to UnstructuredGrid.
.. deprecated:: 0.46
This function is deprecated. Use :meth:`pyvista.DataSetFilters.voxelize` instead.
Parameters
----------
mesh : pyvista.DataSet
Mesh to voxelize.
density : float | array_like[float]
The uniform size of the voxels when single float passed.
A list of densities along x,y,z directions.
Defaults to 1/100th of the mesh length.
check_surface : bool, default: True
Specify whether to check the surface for closure. If on, then the
algorithm first checks to see if the surface is closed and
manifold. If the surface is not closed and manifold, a runtime
error is raised.
enclosed : bool, default: False
If True, the voxel bounds will be outside the mesh.
If False, the voxel bounds will be at or inside the mesh bounds.
fit_bounds : bool, default: False
If enabled, the end bound of the input mesh is used as the end bound of the
voxel grid and the density is updated to the closest compatible one. Otherwise,
the end bound is excluded. Has no effect if `enclosed` is enabled.
Returns
-------
pyvista.UnstructuredGrid
Voxelized unstructured grid of the original mesh.
Notes
-----
Prior to version 0.39.0, this method improperly handled the order of
structured coordinates.
See Also
--------
pyvista.DataSetFilters.voxelize_rectilinear
Similar function that returns a :class:`pyvista.RectilinearGrid` with cell data.
pyvista.DataSetFilters.voxelize_binary_mask
Similar function that returns a :class:`pyvista.ImageData` with point data.
Examples
--------
Create an equal density voxelized mesh.
>>> import pyvista as pv
>>> from pyvista import examples
>>> mesh = examples.download_bunny_coarse().clean() # doctest:+SKIP
>>> vox = pv.voxelize(mesh, density=0.01) # doctest:+SKIP
>>> vox.plot(show_edges=True) # doctest:+SKIP
Create a voxelized mesh using unequal density dimensions.
>>> vox = pv.voxelize(mesh, density=[0.01, 0.005, 0.002]) # doctest:+SKIP
>>> vox.plot(show_edges=True) # doctest:+SKIP
Create an equal density voxel volume without enclosing input mesh.
>>> vox = pv.voxelize(mesh, density=0.01) # doctest:+SKIP
>>> vox = vox.select_enclosed_points(mesh, tolerance=0.0) # doctest:+SKIP
>>> vox.plot(scalars='SelectedPoints', show_edges=True) # doctest:+SKIP
Create an equal density voxel volume enclosing input mesh.
>>> vox = pv.voxelize(mesh, density=0.01, enclosed=True) # doctest:+SKIP
>>> vox = vox.select_enclosed_points(mesh, tolerance=0.0) # doctest:+SKIP
>>> vox.plot(scalars='SelectedPoints', show_edges=True) # doctest:+SKIP
Create a voxelized mesh that does not fit the input mesh's bounds. Notice the
cropped rectangular box.
>>> mesh = pv.Cube(x_length=0.25) # doctest:+SKIP
>>> vox = pv.voxelize(mesh=mesh, density=0.2) # doctest:+SKIP
>>> pl = pv.Plotter() # doctest:+SKIP
>>> _ = pl.add_mesh(mesh=vox, show_edges=True, color='yellow') # doctest:+SKIP
>>> _ = pl.add_mesh(
... mesh=mesh, show_edges=True, line_width=5, opacity=0.4
... ) # doctest:+SKIP
>>> pl.show() # doctest:+SKIP
Create a voxelized mesh that fits the input mesh's bounds. The rectangular mesh is
now complete. Notice that the voxel size was updated to fit the bounds in the first
direction.
>>> vox = pv.voxelize(mesh=mesh, density=0.2, fit_bounds=True) # doctest:+SKIP
>>> pl = pv.Plotter() # doctest:+SKIP
>>> _ = pl.add_mesh(mesh=vox, show_edges=True, color='yellow') # doctest:+SKIP
>>> _ = pl.add_mesh(
... mesh=mesh, show_edges=True, line_width=5, opacity=0.4
... ) # doctest:+SKIP
>>> pl.show() # doctest:+SKIP
voxelize_volume(mesh, density=None, check_surface: 'bool' = True, enclosed: 'bool' = False, fit_bounds: 'bool' = False)
Voxelize mesh to create a RectilinearGrid voxel volume.
Creates a voxel volume that encloses the input mesh and discretizes the cells
within the volume that intersect or are contained within the input mesh.
``InsideMesh``, an array in ``cell_data``, is ``1`` for cells inside and ``0`` outside.
.. deprecated:: 0.46
This function is deprecated. Use :meth:`pyvista.DataSetFilters.voxelize_rectilinear`
instead.
Parameters
----------
mesh : pyvista.DataSet
Mesh to voxelize.
density : float | array_like[float]
The uniform size of the voxels when single float passed.
Nonuniform voxel size if a list of values are passed along x,y,z directions.
Defaults to 1/100th of the mesh length.
check_surface : bool, default: True
Specify whether to check the surface for closure. If on, then the
algorithm first checks to see if the surface is closed and
manifold. If the surface is not closed and manifold, a runtime
error is raised.
enclosed : bool, default: False
If True, the voxel bounds will be outside the mesh.
If False, the voxel bounds will be at or inside the mesh bounds.
fit_bounds : bool, default: False
If enabled, the end bound of the input mesh is used as the end bound of the
voxel grid and the density is updated to the closest compatible one. Otherwise,
the end bound is excluded. Has no effect if `enclosed` is enabled.
Returns
-------
pyvista.RectilinearGrid
RectilinearGrid as voxelized volume with discretized cells.
See Also
--------
pyvista.DataSetFilters.voxelize
Similar function that returns a :class:`pyvista.UnstructuredGrid` of
:attr:`~pyvista.CellType.VOXEL` cells.
pyvista.DataSetFilters.voxelize_binary_mask
Similar function that returns a :class:`pyvista.ImageData` with point data.
pyvista.DataSetFilters.select_enclosed_points
Examples
--------
Create an equal density voxel volume from input mesh.
>>> import pyvista as pv
>>> import numpy as np
Load file from PyVista examples.
>>> from pyvista import examples
>>> mesh = examples.download_cow() # doctest:+SKIP
Create an equal density voxel volume and plot the result.
>>> vox = pv.voxelize_volume(mesh, density=0.15) # doctest:+SKIP
>>> cpos = [(15, 3, 15), (0, 0, 0), (0, 0, 0)] # doctest:+SKIP
>>> vox.plot(scalars='InsideMesh', show_edges=True, cpos=cpos) # doctest:+SKIP
Slice the voxel volume to view ``InsideMesh``.
>>> slices = vox.slice_orthogonal() # doctest:+SKIP
>>> slices.plot(scalars='InsideMesh', show_edges=True) # doctest:+SKIP
Create a voxel volume from unequal density dimensions and plot result.
>>> vox = pv.voxelize_volume(mesh, density=[0.15, 0.15, 0.5]) # doctest:+SKIP
>>> vox.plot(scalars='InsideMesh', show_edges=True, cpos=cpos) # doctest:+SKIP
Slice the unequal density voxel volume to view ``InsideMesh``.
>>> slices = vox.slice_orthogonal() # doctest:+SKIP
>>> slices.plot(
... scalars='InsideMesh', show_edges=True, cpos=cpos
... ) # doctest:+SKIP
Create an equal density voxel volume without enclosing input mesh.
>>> vox = pv.voxelize_volume(mesh, density=0.15) # doctest:+SKIP
>>> vox = vox.select_enclosed_points(mesh, tolerance=0.0) # doctest:+SKIP
>>> vox.plot(
... scalars='SelectedPoints', show_edges=True, cpos=cpos
... ) # doctest:+SKIP
Create an equal density voxel volume enclosing input mesh.
>>> vox = pv.voxelize_volume(
... mesh, density=0.15, enclosed=True
... ) # doctest:+SKIP
>>> vox = vox.select_enclosed_points(mesh, tolerance=0.0) # doctest:+SKIP
>>> vox.plot(
... scalars='SelectedPoints', show_edges=True, cpos=cpos
... ) # doctest:+SKIP
Create an equal density voxel volume that does not fit the input mesh's bounds.
>>> mesh = pv.examples.load_nut() # doctest:+SKIP
>>> vox = pv.voxelize_volume(mesh=mesh, density=2.5) # doctest:+SKIP
>>> pl = pv.Plotter() # doctest:+SKIP
>>> _ = pl.add_mesh(mesh=vox, show_edges=True) # doctest:+SKIP
>>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1) # doctest:+SKIP
>>> pl.show() # doctest:+SKIP
Create an equal density voxel volume that fits the input mesh's bounds.
>>> vox = pv.voxelize_volume(
... mesh=mesh, density=2.5, fit_bounds=True
... ) # doctest:+SKIP
>>> pl = pv.Plotter() # doctest:+SKIP
>>> _ = pl.add_mesh(mesh=vox, show_edges=True) # doctest:+SKIP
>>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1) # doctest:+SKIP
>>> pl.show() # doctest:+SKIP
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\features.py
pyvista.field_array
Python Library Documentation: function field_array in module pyvista.core.utilities.arrays
field_array(obj: 'DataSet | _vtk.vtkDataSet', name: 'str') -> 'pyvista_ndarray | None'
Return field data of a pyvista or vtk object.
Parameters
----------
obj : DataSet | :vtk:`vtkDataSet`
PyVista or VTK dataset.
name : str | int
Name or index of the array.
Returns
-------
output : pyvista.pyvista_ndarray | None
Wrapped array if the index or name is valid. Otherwise, ``None``.
pyvista.fileio
Python Library Documentation: module pyvista.core.utilities.fileio in pyvista.core.utilities
NAME
pyvista.core.utilities.fileio - Contains a dictionary that maps file extensions to VTK readers.
FUNCTIONS
from_meshio(mesh: 'meshio.Mesh') -> 'UnstructuredGrid'
Convert a ``meshio`` mesh instance to a PyVista mesh.
Parameters
----------
mesh : meshio.Mesh
A mesh instance from the ``meshio`` library.
Returns
-------
pyvista.UnstructuredGrid
A PyVista unstructured grid representation of the input ``meshio`` mesh.
Raises
------
ImportError
If the appropriate version of ``meshio`` library is not found.
from_trimesh(mesh: 'trimesh.Trimesh', *, pass_data: '_PassDataOptions' = True) -> 'PolyData'
Convert a Trimesh mesh to a PyVista mesh.
- ``vertex_attributes`` are stored as point data.
- ``face_attributes`` are stored as cell data.
- ``metadata`` is stored as field data: NumPy arrays are stored directly as field data
arrays, and any other metadata (e.g. strings or lists) is stored in the
:attr:`~pyvista.DataObject.user_dict`.
.. note::
No copies of point, cell, or data arrays are made. Use :meth:`~pyvista.DataObject.copy`
after converting to avoid any side effects.
.. versionadded:: 0.47
Parameters
----------
mesh : trimesh.Trimesh
Trimesh object to convert.
pass_data : bool | str | sequence[str], default: True
Pass point, cell, and/or field data from the Trimesh object. All data is passed by default.
Set this to ``'point'``, ``'cell'``, ``'field'`` or any combination thereof to only pass
specific fields.
See Also
--------
to_trimesh, from_meshio, :func:`~pyvista.wrap`
Examples
--------
See :ref:`wrap_trimesh_example` for examples.
get_ext(filename: 'str | Path') -> 'str'
Extract the extension of the filename.
For files with the .gz suffix, the previous extension is returned as well.
This is needed e.g. for the compressed NIFTI format (.nii.gz).
Parameters
----------
filename : str, Path
The filename from which to extract the extension.
Returns
-------
str
The extracted extension. For files with the .gz suffix, the previous
extension is returned as well.
is_meshio_mesh(obj: 'object') -> 'bool'
Test if passed object is an instance of :class:`meshio.Mesh`.
Parameters
----------
obj : object
Any object.
Returns
-------
bool
``True`` if ``obj`` is a :class:`meshio.Mesh`.
is_trimesh_mesh(obj: 'object') -> 'bool'
Test if passed object is an instance of :class:`trimesh.Trimesh`.
.. versionadded:: 0.47
Parameters
----------
obj : object
Any object.
Returns
-------
bool
``True`` if ``obj`` is a :class:`trimesh.Trimesh`.
read(filename: 'PathStrSeq', force_ext: 'str | None' = None, file_format: 'str | None' = None, progress_bar: 'bool' = False, *, cls: 'type[DataObject] | None' = None, validate: 'bool | None' = None) -> 'DataObject'
Read any file type supported by ``vtk`` or ``meshio``.
Automatically determines the correct reader to use then wraps the
corresponding mesh as a pyvista object. Attempts native ``vtk``
readers first then tries to use ``meshio``. :py:mod:`Pickled<pickle>`
meshes (``'.pkl'`` or ``'.pickle'``) are also supported.
Remote URIs (``https://``, ``s3://``, etc.) are downloaded to a
temporary file automatically. Install ``fsspec`` for full protocol
support (``pip install pyvista[io]``); ``pooch`` is used as a
fallback for HTTP(S). Third-party reader plugins registered via
:func:`pyvista.register_reader` are also checked.
See :func:`pyvista.get_reader` for list of vtk formats supported.
.. include:: /api/utilities/mesh_io.rst
.. note::
See https://github.com/nschloe/meshio for formats supported by
``meshio``. Be sure to install ``meshio`` with ``pip install
meshio`` if you wish to use it.
.. versionadded:: 0.45
Support reading pickled meshes.
.. warning::
The pickle module is not secure. Only read pickled mesh files
(``'.pkl'`` or ``'.pickle'``) you trust. See :py:mod:`pickle`
for details.
See Also
--------
pyvista.DataObject.save
Save a mesh to file.
Parameters
----------
filename : str, Path, Sequence[str | Path]
The string path to the file to read. If a list of files is
given, a :class:`pyvista.MultiBlock` dataset is returned with
each file being a separate block in the dataset.
force_ext : str, optional
If specified, the reader will be chosen by an extension which
is different to its actual extension. For example, ``'.vts'``,
``'.vtu'``.
file_format : str, optional
Format of file to read with meshio.
progress_bar : bool, default: False
Optionally show a progress bar. Ignored when using ``meshio``.
cls : type, optional
Expected concrete type of the returned mesh. When given, the
result is checked with :func:`isinstance` and a
:class:`TypeError` is raised on mismatch. Static type checkers
(``mypy``, ``pyright``) use this to narrow the return type to
``cls`` directly, so callers do not need ``typing.cast`` or a
manual ``assert isinstance`` to access subclass-specific
attributes, e.g. ``pv.read('file.vtu', cls=pv.UnstructuredGrid)``.
validate : bool, optional
Forwarded to :func:`pyvista.wrap` as the ``validate`` keyword when
using a ``vtk`` reader. When ``None`` (the default), honors
:attr:`pyvista.core.config.Config.validate_on_wrap`. Pass ``False`` to
skip the cheap array-length sanity check on very large trusted
files. Has no effect for ``meshio`` or pickle code paths.
.. versionadded:: 0.48
Returns
-------
pyvista.DataSet | pyvista.MultiBlock
Wrapped PyVista dataset. When ``cls`` is given, an instance of
``cls`` is returned instead.
Examples
--------
Load an example mesh.
>>> import pyvista as pv
>>> from pyvista import examples
>>> mesh = pv.read(examples.antfile)
>>> mesh.plot(cpos='xz')
Narrow the return type to a specific class. This avoids the need for
a manual ``cast`` when working with type checkers such as ``mypy``
or ``pyright``.
>>> mesh = pv.read('mesh.vtu', cls=pv.UnstructuredGrid) # doctest:+SKIP
Load a vtk file.
>>> mesh = pv.read('my_mesh.vtk') # doctest:+SKIP
Load a meshio file.
>>> mesh = pv.read('mesh.obj') # doctest:+SKIP
Load a pickled mesh file.
>>> mesh = pv.read('mesh.pkl') # doctest:+SKIP
read_exodus(filename: 'str | Path', animate_mode_shapes: 'bool' = True, apply_displacements: 'bool' = True, displacement_magnitude: 'float' = 1.0, read_point_data: 'bool' = True, read_cell_data: 'bool' = True, enabled_sidesets: 'Iterable[str | int] | None' = None) -> 'DataSet | MultiBlock'
Read an ExodusII file (``'.e'`` or ``'.exo'``).
Parameters
----------
filename : str, Path
The path to the exodus file to read.
animate_mode_shapes : bool, default: True
When ``True`` then this reader will report a continuous time
range [0,1] and animate the displacements in a periodic
sinusoid.
apply_displacements : bool, default: True
Geometric locations can include displacements. When ``True``,
the nodal positions are 'displaced' by the standard exodus
displacement vector. If displacements are turned off, the user
can explicitly add them by applying a warp filter.
displacement_magnitude : float, default: 1.0
This is a number between 0 and 1 that is used to scale the
``DisplacementMagnitude`` in a sinusoidal pattern.
read_point_data : bool, default: True
Read in data associated with points.
read_cell_data : bool, default: True
Read in data associated with cells.
enabled_sidesets : Iterable[str | int], optional
The name of the array that store the mapping from side set
cells back to the global id of the elements they bound.
Returns
-------
pyvista.DataSet
Wrapped PyVista dataset.
Examples
--------
>>> import pyvista as pv
>>> data = pv.read_exodus('mymesh.exo') # doctest:+SKIP
read_grdecl(filename: 'str | Path', elevation: 'bool' = True, other_keywords: 'Sequence[str] | None' = None) -> 'ExplicitStructuredGrid'
Read a GRDECL file (``'.GRDECL'``).
Parameters
----------
filename : str | Path
The path to the GRDECL file to read.
elevation : bool, default: True
If True, convert depths to elevations and flip grid along Z axis.
other_keywords : sequence[str], optional
Additional keywords to read that are ignored by default.
Returns
-------
pyvista.ExplicitStructuredGrid
Output explicit structured grid.
Examples
--------
Read a ``'.GRDECL'`` file.
>>> import pyvista as pv
>>> grid = pv.read('file.GRDECL') # doctest:+SKIP
Unused keywords contained in the file are stored in :attr:`pyvista.DataObject.user_dict`:
>>> grid.user_dict # doctest:+SKIP
{"MAPUNITS": ..., "GRIDUNIT": ..., ...}
read_meshio(filename: 'str | Path', file_format: 'str | None' = None) -> 'UnstructuredGrid'
Read any mesh file using meshio.
Parameters
----------
filename : str
The name of the file to read. It should include the file extension.
file_format : str, optional
The format of the file to read. If not provided, the file format will
be inferred from the file extension.
Returns
-------
UnstructuredGrid
The mesh read from the file.
Raises
------
ImportError
If the meshio package is not installed.
read_pickle(filename: 'str | Path') -> 'DataObject'
Load a pickled mesh from file.
Parameters
----------
filename : str
The path of the pickled mesh to read.
Returns
-------
pyvista.DataObject
Unpickled mesh.
Examples
--------
Save a pickled mesh and read it.
>>> import pyvista as pv
>>> from pyvista import examples
>>> mesh = examples.load_ant()
>>> pv.save_pickle('ant.pkl', mesh)
>>> new_mesh = pv.read_pickle('ant.pkl')
>>> new_mesh
PolyData (...)
N Cells: 912
N Points: 486
N Strips: 0
X Bounds: -1.601e+01, 1.601e+01
Y Bounds: -9.385e+00, 9.385e+00
Z Bounds: -1.678e+01, 1.678e+01
N Arrays: 0
Unlike other file formats, custom attributes are saved with pickled meshes.
>>> pv.set_new_attribute(mesh, 'custom_attribute', 42)
>>> pv.save_pickle('ant.pkl', mesh)
>>> new_mesh = pv.read_pickle('ant.pkl')
>>> new_mesh.custom_attribute
42
read_texture(filename: 'str | Path', progress_bar: 'bool' = False) -> 'Texture'
Load a texture from an image file.
Will attempt to read any file type supported by ``vtk``, however
if it fails, it will attempt to use ``imageio`` to read the file.
Parameters
----------
filename : str
The path of the texture file to read.
progress_bar : bool, default: False
Optionally show a progress bar.
Returns
-------
pyvista.Texture
PyVista texture object.
Examples
--------
Read in an example jpg map file as a texture.
>>> from pathlib import Path
>>> import pyvista as pv
>>> from pyvista import examples
>>> Path(examples.mapfile).name
'2k_earth_daymap.jpg'
>>> texture = pv.read_texture(examples.mapfile)
>>> type(texture)
<class 'pyvista.plotting.texture.Texture'>
save_meshio(filename: 'str | Path', mesh: 'DataSet', file_format: 'str | None' = None, **kwargs) -> 'None'
Save mesh to file using meshio.
Parameters
----------
filename : str
Filename to save the mesh to.
mesh : pyvista.DataSet
Any PyVista mesh/spatial data type.
file_format : str, optional
File type for meshio to save. For example ``'.bdf'``. This
is normally inferred from the extension but this can be
overridden.
**kwargs : dict, optional
Additional keyword arguments. See
``meshio.Mesh.write`` for more details.
Examples
--------
Save a pyvista sphere to a Abaqus data file.
>>> import pyvista as pv
>>> sphere = pv.Sphere()
>>> pv.save_meshio('mymesh.inp', sphere) # doctest:+SKIP
save_pickle(filename: 'str | Path', mesh: 'DataObject') -> 'None'
Pickle a mesh and save it to file.
Parameters
----------
filename : str
The path of the pickled mesh to save, including the extension ``'.pkl'``
or ``'.pickle'``.
mesh : pyvista.DataObject
Any PyVista mesh.
Examples
--------
Save a pickled mesh and read it.
>>> import pyvista as pv
>>> from pyvista import examples
>>> mesh = examples.load_ant()
>>> pv.save_pickle('ant.pkl', mesh)
>>> new_mesh = pv.read_pickle('ant.pkl')
>>> new_mesh
PolyData (...)
N Cells: 912
N Points: 486
N Strips: 0
X Bounds: -1.601e+01, 1.601e+01
Y Bounds: -9.385e+00, 9.385e+00
Z Bounds: -1.678e+01, 1.678e+01
N Arrays: 0
Unlike other file formats, custom attributes are saved with pickled meshes.
>>> pv.set_new_attribute(mesh, 'custom_attribute', 42)
>>> pv.save_pickle('ant.pkl', mesh)
>>> new_mesh = pv.read_pickle('ant.pkl')
>>> new_mesh.custom_attribute
42
set_pickle_format(format: "Literal['vtk', 'xml', 'legacy']") -> 'None'
Set the format used to serialize :class:`pyvista.DataObject` when pickled.
Parameters
----------
format : str
The format for serialization. Acceptable values are:
- ``'vtk'`` (default) : objects are serialized using VTK's official
marshalling methods.
- ``'xml'``: objects are serialized as an XML-formatted string.
- ``'legacy'`` objects are serialized to bytes in VTK's binary format.
.. note::
The ``'vtk'`` format requires VTK 9.3 or greater.
.. warning::
``'xml'`` and ``'legacy'`` are not recommended. These formats are not
officially supported by VTK and have limitations. For example, these
formats cannot be used to pickle :class:`pyvista.MultiBlock`.
Raises
------
ValueError
If the provided format is not supported.
to_meshio(mesh: 'DataSet') -> 'meshio.Mesh'
Convert a PyVista mesh to a ``meshio`` mesh instance.
.. versionadded:: 0.45
Parameters
----------
mesh : pyvista.DataSet
Any PyVista mesh/spatial data type.
Returns
-------
meshio.Mesh
A mesh instance from the ``meshio`` library.
Raises
------
ImportError
If the meshio package is not installed.
See Also
--------
from_meshio, read_meshio, save_meshio, :func:`~pyvista.wrap`
Examples
--------
Convert a pyvista sphere to a ``meshio`` mesh instance.
>>> import pyvista as pv
>>> sphere = pv.Sphere()
>>> mesh = pv.to_meshio(sphere)
to_trimesh(mesh: 'DataSet', *, triangulate: 'bool' = False, pass_data: '_PassDataOptions' = True) -> 'trimesh.Trimesh'
Convert a PyVista mesh to a Trimesh mesh.
- Point data is stored as ``vertex_attributes``.
- Cell data is stored as ``face_attributes``.
- Field data is stored as ``metadata``. Any :attr:`~pyvista.DataObject.user_dict` keys
are stored directly as metadata.
.. note::
No copies of point, cell, or data arrays are made. Use :meth:`~pyvista.DataObject.copy`
before converting to avoid any side effects.
.. versionadded:: 0.47
Parameters
----------
mesh : DataSet
Dataset to convert.
triangulate : bool, default: False
Triangulate the mesh before conversion. If the mesh has 3D cells, the mesh's surface
is extracted. All 2D polygonal cells are triangulated as required, and all 0D and 1D
cells or any unused points are ignored.
pass_data : bool | str | sequence[str], default: True
Pass point, cell, and/or field data to the Trimesh object. All data is passed by default.
Set this to ``'point'``, ``'cell'``, ``'field'`` or any combination thereof to only pass
specific fields.
See Also
--------
from_trimesh, to_meshio, :func:`~pyvista.wrap`
Examples
--------
See :ref:`wrap_trimesh_example` for examples.
DATA
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
PICKLE_EXT = ('.pkl', '.pickle')
PathStrSeq = str | pathlib.Path | collections.abc.Sequence['PathStrSeq...
TYPE_CHECKING = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\fileio.py
pyvista.filters
Python Library Documentation: package pyvista.core.filters in pyvista.core
NAME
pyvista.core.filters - These classes hold methods to apply general filters to any data type.
DESCRIPTION
By inheriting these classes into the wrapped VTK data structures, a user
can easily apply common filters in an intuitive manner.
Examples
--------
>>> import pyvista as pv
>>> from pyvista import examples
>>> dataset = examples.load_uniform()
>>> # Threshold
>>> thresh = dataset.threshold([100, 500])
>>> # Slice
>>> slc = dataset.slice()
>>> # Clip
>>> clp = dataset.clip(invert=True)
>>> # Contour
>>> iso = dataset.contour()
PACKAGE CONTENTS
composite
data_object
data_set
image_data
poly_data
rectilinear_grid
structured_grid
unstructured_grid
CLASSES
builtins.object
pyvista.core.filters.data_object.DataObjectFilters
pyvista.core.filters.composite.CompositeFilters
pyvista.core.filters.data_set.DataSetFilters(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.filters.data_object.DataObjectFilters)
pyvista.core.filters.image_data.ImageDataFilters
pyvista.core.filters.poly_data.PolyDataFilters
pyvista.core.filters.structured_grid.StructuredGridFilters
pyvista.core.filters.unstructured_grid.UnstructuredGridFilters
pyvista.core.filters.rectilinear_grid.RectilinearGridFilters
pyvista.core.utilities.misc._BoundsSizeMixin(builtins.object)
pyvista.core.filters.data_set.DataSetFilters(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.filters.data_object.DataObjectFilters)
pyvista.core.filters.image_data.ImageDataFilters
pyvista.core.filters.poly_data.PolyDataFilters
pyvista.core.filters.structured_grid.StructuredGridFilters
pyvista.core.filters.unstructured_grid.UnstructuredGridFilters
class CompositeFilters(pyvista.core.filters.data_object.DataObjectFilters)
| CompositeFilters(*args, **kwargs)
|
| An internal class to manage filters/algorithms for composite datasets.
|
| Method resolution order:
| CompositeFilters
| pyvista.core.filters.data_object.DataObjectFilters
| builtins.object
|
| Methods defined here:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| combine(self, merge_points: 'bool' = False, tolerance=0.0)
| Combine all blocks into a single unstructured grid.
|
| Parameters
| ----------
| merge_points : bool, default: False
| Merge coincidental points.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Combined blocks.
|
| Examples
| --------
| Combine blocks within a multiblock without merging points.
|
| >>> import pyvista as pv
| >>> block = pv.MultiBlock(
| ... [
| ... pv.Cube(clean=False),
| ... pv.Cube(center=(1, 0, 0), clean=False),
| ... ]
| ... )
| >>> merged = block.combine()
| >>> merged.n_points
| 48
|
| Combine blocks and merge points
|
| >>> merged = block.combine(merge_points=True)
| >>> merged.n_points
| 12
|
| extract_geometry(self)
| Extract the surface the geometry of all blocks.
|
| Place this filter at the end of a pipeline before a polydata
| consumer such as a polydata mapper to extract geometry from
| all blocks and append them to one polydata object.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the composite dataset.
|
| generic_filter(self: 'MultiBlock', function: 'str | Callable[..., _TypeMultiBlockLeaf]', /, *args, **kwargs) -> 'MultiBlock'
| Apply any filter to all nested blocks recursively.
|
| This filter applies a user-specified function or method to all blocks in
| this :class:`~pyvista.MultiBlock`.
|
| .. note::
|
| If an ``inplace`` keyword is used, this ``MultiBlock`` is modified
| in-place along with all blocks.
|
| .. note::
|
| By default, the specified ``function`` is not applied to any ``None``
| blocks. These are simply skipped and passed through to the output.
|
| For advanced use, it is possible to apply the filter to ``None`` blocks
| by using the undocumented keyword ``_skip_none=False``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| function : Callable | str
| Callable function or name of the method to apply to each block. The function
| should accept a :class:`~pyvista.DataSet` as input and return either a
| :class:`~pyvista.DataSet` or :class:`~pyvista.MultiBlock` as output.
|
| *args : Any, optional
| Arguments to use with the specified ``function``.
|
| **kwargs : Any, optional
| Keyword arguments to use with the specified ``function``.
|
| Returns
| -------
| MultiBlock
| Filtered dataset.
|
| Raises
| ------
| RuntimeError
| Raised if the filter cannot be applied to any block for any reason. This
| overrides ``TypeError``, ``ValueError``, ``AttributeError`` errors when
| filtering.
|
| See Also
| --------
| pyvista.MultiBlock.flatten
| pyvista.MultiBlock.recursive_iterator
| pyvista.MultiBlock.clean
|
| Examples
| --------
| Create a :class:`~pyvista.MultiBlock` with various mesh types.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> volume = examples.load_uniform()
| >>> poly = examples.load_ant()
| >>> unstructured = examples.load_tetbeam()
| >>> multi = pv.MultiBlock([volume, poly, unstructured])
|
| >>> [type(block) for block in multi] # doctest: +NORMALIZE_WHITESPACE
| [<class 'pyvista.core.grid.ImageData'>,
| <class 'pyvista.core.pointset.PolyData'>,
| <class 'pyvista.core.pointset.UnstructuredGrid'>]
|
| Use the generic filter to apply :meth:`~pyvista.DataSet.cast_to_unstructured_grid`
| to all blocks.
|
| >>> filtered = multi.generic_filter('cast_to_unstructured_grid')
|
| >>> [type(block) for block in filtered] # doctest: +NORMALIZE_WHITESPACE
| [<class 'pyvista.core.pointset.UnstructuredGrid'>,
| <class 'pyvista.core.pointset.UnstructuredGrid'>,
| <class 'pyvista.core.pointset.UnstructuredGrid'>]
|
| Use the :meth:`~pyvista.DataSetFilters.partition` filter on all blocks.
| Any arguments can be specified as though the filter is being used directly.
|
| >>> filtered = multi.generic_filter('partition', 4, as_composite=True)
|
| Any function can be used as long as it returns a :class:`~pyvista.DataSet` or
| :class:`~pyvista.MultiBlock`. For example, we can normalize each block
| independently to have bounds between ``-0.5`` and ``0.5``.
|
| >>> def normalize_bounds(dataset):
| ... # Center the dataset
| ... dataset = dataset.translate(-np.array(dataset.center))
| ... # Scale the dataset
| ... factor = 1 / np.array(dataset.bounds_size)
| ... return dataset.scale(factor)
|
| >>> filtered = multi.generic_filter(normalize_bounds)
| >>> filtered
| MultiBlock (...)
| N Blocks: 3
| X Bounds: -5.000e-01, 5.000e-01
| Y Bounds: -5.000e-01, 5.000e-01
| Z Bounds: -5.000e-01, 5.000e-01
|
| The generic filter will fail if the filter can only be applied to some blocks
| but not others. For example, it is not possible to use the
| :meth:`~pyvista.ImageDataFilters.resample` filter generically since the
| ``MultiBlock`` above is heterogeneous and contains some blocks which are not
| :class:`~pyvista.ImageData`.
|
| >>> multi.generic_filter('resample', 0.5) # doctest:+SKIP
| RuntimeError: The filter 'resample' could not be applied to the block at index 1 with
| name 'Block-01' and type PolyData.
|
| Use a custom function instead to apply the generic filter conditionally. Here we
| filter the image blocks but simply pass-through a copy of any other blocks.
|
| >>> def conditional_resample(dataset, *args, **kwargs):
| ... if isinstance(dataset, pv.ImageData):
| ... return dataset.resample(*args, **kwargs)
| ... return dataset.copy()
|
| >>> filtered = multi.generic_filter(conditional_resample, 0.5)
|
| outline(self: 'MultiBlock', generate_faces: 'bool' = False, nested: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the all blocks in this composite dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box.
|
| nested : bool, default: False
| If ``True``, these creates individual outlines for each nested dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the outline.
|
| outline_corners(self: 'MultiBlock', factor=0.2, nested: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the corners for the all blocks in this composite dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| nested : bool, default: False
| If ``True``, these creates individual outlines for each nested dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class DataObjectFilters(builtins.object)
| DataObjectFilters(*args, **kwargs)
|
| A set of common filters that can be applied to any DataSet or MultiBlock.
|
| Methods defined here:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'points': 'pyvista_ndarray'}
class DataSetFilters(pyvista.core.utilities.misc._BoundsSizeMixin, pyvista.core.filters.data_object.DataObjectFilters)
| DataSetFilters(*args, **kwargs)
|
| A set of common filters that can be applied to any :vtk:`vtkDataSet`.
|
| Method resolution order:
| DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| builtins.object
|
| Methods defined here:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
class ImageDataFilters(pyvista.core.filters.data_set.DataSetFilters)
| ImageDataFilters(*args, **kwargs)
|
| An internal class to manage filters/algorithms for uniform grid datasets.
|
| Method resolution order:
| ImageDataFilters
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| builtins.object
|
| Methods defined here:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| cells_to_points(self: 'ImageData', scalars: 'str | None' = None, *, dimensionality: "VectorLike[bool] | Literal[0, 1, 2, 3, '0D', '1D', '2D', '3D', 'preserve']" = 'preserve', copy: 'bool' = True)
| Re-mesh image data from a cell-based to a point-based representation.
|
| This filter changes how image data is represented. Data represented as cells
| at the input is re-meshed into an alternative representation as points at the
| output. Only the :class:`~pyvista.ImageData` container is modified so that
| the number of input cells equals the number of output points. The re-meshing is
| otherwise lossless in the sense that cell data at the input is passed through
| unmodified and stored as point data at the output. Any point data at the input is
| ignored and is not used by this filter.
|
| To change the image data's representation, the input cell centers are used to
| represent the output points. This has the effect of "shrinking" the
| input image dimensions by one along each axis (i.e. half the cell width on each
| side). For example, an image with 101 points and 100 cells along an axis at the
| input will have 100 points and 99 cells at the output. If the input has 1mm
| spacing, the axis size will also decrease from 100mm to 99mm.
|
| Since filters may be inherently cell-based (e.g. some :class:`~pyvista.DataSetFilters`)
| or may operate on point data exclusively (e.g. most :class:`~pyvista.ImageDataFilters`),
| re-meshing enables the same data to be used with either kind of filter while
| ensuring the input data to those filters has the appropriate representation.
| This filter is also useful when plotting image data to achieve a desired visual
| effect, such as plotting images as points instead of as voxel cells.
|
| .. note::
| Only the input's :attr:`~pyvista.ImageData.dimensions`, and
| :attr:`~pyvista.ImageData.origin` are modified by this filter. Other spatial
| properties such as :attr:`~pyvista.ImageData.spacing` and
| :attr:`~pyvista.ImageData.direction_matrix` are not affected.
|
| .. versionadded:: 0.44.0
|
| See Also
| --------
| points_to_cells
| Inverse of this filter to represent points as cells.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample cell data as point data without modifying the container.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample point data as cell data without modifying the container.
|
| Parameters
| ----------
| scalars : str, optional
| Name of cell data scalars to pass through to the output as point data. Use
| this parameter to restrict the output to only include the specified array.
| By default, all cell data arrays at the input are passed through as point
| data at the output.
|
| dimensionality : VectorLike[bool], Literal[0, 1, 2, 3, "0D", "1D", "2D", "3D", "preserve"]
| Control which dimensions will be modified by the filter.
| ``'preserve'`` is used by default.
|
| - Can be specified as a sequence of 3 boolean to allow modification on a per
| dimension basis.
| - ``0`` or ``'0D'``: convenience alias to output a 0D ImageData with
| dimensions ``(1, 1, 1)``. Only valid for 0D inputs.
| - ``1`` or ``'1D'``: convenience alias to output a 1D ImageData where
| exactly one dimension is greater than one, e.g. ``(>1, 1, 1)``. Only valid
| for 0D or 1D inputs.
| - ``2`` or ``'2D'``: convenience alias to output a 2D ImageData where
| exactly two dimensions are greater than one, e.g. ``(>1, >1, 1)``. Only
| valid for 0D, 1D, or 2D inputs.
| - ``3`` or ``'3D'``: convenience alias to output a 3D ImageData, where all
| three dimensions are greater than one, e.g. ``(>1, >1, >1)``. Valid for
| any 0D, 1D, 2D, or 3D inputs.
| - ``'preserve'`` (default): convenience alias to not modify singleton
| dimensions.
|
| .. note::
| This filter does not modify singleton dimensions with ``dimensionality``
| set as ``'preserve'`` by default.
|
| copy : bool, default: True
| Copy the input cell data before associating it with the output point data.
| If ``False``, the input and output will both refer to the same data array(s).
|
| Returns
| -------
| pyvista.ImageData
| Image with a point-based representation.
|
| Examples
| --------
| Load an image with cell data.
|
| >>> from pyvista import examples
| >>> image = examples.load_uniform()
|
| Show the current properties and cell arrays of the image.
|
| >>> image
| ImageData (...)
| N Cells: 729
| N Points: 1000
| X Bounds: 0.000e+00, 9.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| Dimensions: 10, 10, 10
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 2
|
| >>> image.cell_data.keys()
| ['Spatial Cell Data']
|
| Re-mesh the cells and cell data as points and point data.
|
| >>> points_image = image.cells_to_points()
|
| Show the properties and point arrays of the re-meshed image.
|
| >>> points_image
| ImageData (...)
| N Cells: 512
| N Points: 729
| X Bounds: 5.000e-01, 8.500e+00
| Y Bounds: 5.000e-01, 8.500e+00
| Z Bounds: 5.000e-01, 8.500e+00
| Dimensions: 9, 9, 9
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> points_image.point_data.keys()
| ['Spatial Cell Data']
|
| Observe that:
|
| - The input cell array is now a point array
| - The output has one less array (the input point data is ignored)
| - The dimensions have decreased by one
| - The bounds have decreased by half the spacing
| - The output ``N Points`` equals the input ``N Cells``
|
| See :ref:`image_representations_example` for more examples using this filter.
|
| close(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Perform morphological closing on continuous or binary data.
|
| Closing is a :meth:`dilation <dilate>` followed by an :meth:`erosion <erode>`.
| It is used to fill small holes/gaps while preserving the shape and size of larger objects.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are closed, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary closing or continuous closing is used. Refer to
| :meth:`dilate` and/or :meth:`erode` for details about using this keyword.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been closed.
|
| See Also
| --------
| open, erode, dilate
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| Load a binary image: :func:`~pyvista.examples.downloads.download_yinyang()`.
|
| >>> from pyvista import examples
| >>> im = examples.download_yinyang()
|
| Use ``close`` with a relatively small kernel to fill the top black edge of the yinyang.
|
| >>> closed = im.close(kernel_size=5)
| >>> kwargs = dict(
| ... cmap='grey',
| ... lighting=False,
| ... cpos='xy',
| ... zoom='tight',
| ... show_axes=False,
| ... show_scalar_bar=False,
| ... )
| >>> closed.plot(**kwargs)
|
| Use a much larger kernel to also fill the small black circle.
|
| >>> closed = im.close(kernel_size=25)
| >>> closed.plot(**kwargs)
|
| Since closing is the inverse of opening, we can alternatively use :meth:`open` to
| fill the white foreground values instead of the black background.
|
| >>> opened = im.open(kernel_size=25)
| >>> opened.plot(**kwargs)
|
| concatenate(self: 'ImageData', images: 'ImageData | Sequence[ImageData]', axis: '_AxisOptions | None' = None, *, mode: '_ConcatenateModeOptions | None' = None, dtype_policy: '_ConcatenateDTypePolicyOptions | None' = None, component_policy: '_ConcatenateComponentPolicyOptions | None' = None, background_value: 'float | VectorLike[float]' = 0.0, resample_kwargs: 'dict[str, Any] | None' = None)
| Combine multiple images into one.
|
| This filter uses :vtk:`vtkImageAppend` to combine multiple images. By default, images are
| concatenated along the specified ``axis``, and all images must have:
|
| #. identical dimensions except along the specified ``axis``,
| #. the same scalar dtype, and
| #. the same number of scalar components.
|
| Use ``mode`` for cases with mismatched dimensions, ``dtype_policy`` for cases with
| mismatched dtypes, and/or ``component_policy`` for cases with mismatched scalar components.
|
| The output has the same :attr:`~pyvista.ImageData.origin` and
| :attr:`~pyvista.ImageData.spacing` as the first input. The origin and spacing of all other
| inputs are ignored.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| images : ImageData | Sequence[ImageData]
| The input image(s) to concatenate. The default active scalars are used for all images.
|
| axis : int | str, default: 'x'
| Axis along which the images are concatenated:
|
| - ``0`` or ``'x'``: x-axis
| - ``1`` or ``'y'``: y-axis
| - ``2`` or ``'z'``: z-axis
|
| mode : str, default: 'strict'
| Concatenation mode to use. This determines how images are placed in the output. All
| modes operate along the specified ``axis`` except for ``'preserve-extents'``.
| Specify one of:
|
| - ``'strict'``: all images must have identical dimensions except along the specified
| ``axis``.
| - ``'resample-off-axis'``: :meth:`resample` off-axis dimensions of concatenated images
| to match the input. The on-axis dimension is `not` resampled.
| - ``'resample-match'``: :meth:`resample` all dimensions of concatenated images
| to match the input dimensions exactly. This is similar to ``'resample-off-axis'``,
| except the on-axis dimension is `also` resampled.
| - ``'resample-proportional'``: :meth:`resample` concatenated images proportionally to
| preserve their aspect ratio(s).
| - ``'crop-off-axis'``: :meth:`crop` off-axis dimensions of concatenated images
| to match the input. The on-axis dimension is `not` cropped.
| - ``'crop-match'``: Use :meth:`crop` to center-crop concatenated images such that
| their dimensions match the input dimensions exactly. This is similar to
| ``'crop-off-axis'``, except the on-axis dimension is `also` cropped.
| - ``'preserve-extents'``: the extents of all images are preserved and used to place the
| images in the output. The whole extent of the output is the union of the input whole
| extents. The origin and spacing is taken from the first input. ``axis`` is not used
| by this mode.
|
| .. note::
| Images may be padded with ``background_value`` in some cases when there are
| mismatched dimensions.
|
| dtype_policy : 'strict' | 'promote' | 'match', default: 'strict'
| - ``'strict'``: Do not cast any scalar array dtypes. All images being concatenated must
| have the same dtype, else a ``TypeError`` is raised.
| - ``'promote'``: Use :func:`numpy.result_type` to compute the dtype of the output
| image scalars. This option safely casts all input arrays to a common dtype before
| concatenating.
| - ``'match'``: Cast all array dtypes to match the input's dtype. This casting is
| unsafe as it may downcast values and lose precision.
|
| component_policy : 'strict' | 'promote_rgba', default: 'strict'
| - ``'strict'``: Do not modify the number of components of any scalars. All images being
| concatenated must have the same number of components, else a ``ValueError`` is
| raised.
| - ``'promote_rgba'``: Increase the number of components if necessary. Grayscale scalars
| with one component may be promoted to RGB scalars by duplicating values,
| and RGB scalars may be promoted to RGBA scalars by including an opacity component.
| For integer dtypes, the opacity is set to the max int representable by the dtype;
| for floats it is set to ``1.0``.
|
| background_value : float | VectorLike[float], default: 0
| Value or multi-component vector to use as background. The output may be padded with
| this value for some ``modes`` when there are mismatched dimensions.
|
| resample_kwargs : dict, optional
| Keyword arguments passed to :meth:`resample` when using ``'resample-off-axis'`` or
| ``'resample-proportional'`` modes. Specify ``interpolation``, ``border_mode`` or
| ``anti_aliasing`` options.
|
| Returns
| -------
| ImageData
| The concatenated image.
|
| Examples
| --------
| .. pyvista-plot::
| :force_static:
|
| Load a 2D image: :func:`~pyvista.examples.downloads.download_beach`.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beach = examples.download_beach()
|
| Use :meth:`select_values` to make a second version with white values converted to black
| to distinguish it from the original.
|
| >>> white = [255, 255, 255]
| >>> black = [0, 0, 0]
| >>> beach_black = beach.select_values(white, fill_value=black, invert=True)
|
| Concatenate them along the x-axis.
|
| >>> concatenated = beach.concatenate(beach_black, axis='x')
| >>> plot_kwargs = dict(
| ... rgb=True,
| ... lighting=False,
| ... cpos='xy',
| ... zoom='tight',
| ... show_axes=False,
| ... show_scalar_bar=False,
| ... )
| >>> concatenated.plot(**plot_kwargs)
|
| Concatenate them along the y-axis.
|
| >>> concatenated = beach.concatenate(beach_black, axis='y')
| >>> concatenated.plot(**plot_kwargs)
|
| By default, concatenation requires that all off-axis dimensions match the input. Use
| the ``mode`` keyword to enable concatenation with mismatched dimensions.
|
| Load a second 2D image with different dimensions:
| :func:`~pyvista.examples.downloads.download_bird`.
|
| >>> bird = examples.download_bird()
| >>> bird.dimensions
| (458, 342, 1)
| >>> beach.dimensions
| (100, 100, 1)
|
| Concatenate using ``'resample-proportional'`` mode to preserve the aspect ratio of the
| concatenated image. Linear interpolation with antialiasing is used to avoid sampling
| artifacts.
|
| >>> resample_kwargs = {'interpolation': 'linear', 'anti_aliasing': True}
| >>> concatenated = beach.concatenate(
| ... bird, mode='resample-proportional', resample_kwargs=resample_kwargs
| ... )
| >>> concatenated.dimensions
| (233, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'resample-proportional'`` again but concontenate along the z-axis instead. The
| ``bird``'s aspect ratio is preserved and padded with zeros so that it can be stacked
| on top of ``beach``.
|
| >>> concatenated = beach.concatenate(
| ... bird,
| ... axis='z',
| ... mode='resample-proportional',
| ... resample_kwargs=resample_kwargs,
| ... )
| >>> concatenated.dimensions
| (100, 100, 2)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'resample-off-axis'`` to only resample off-axis dimensions. This option may
| distort the image.
|
| >>> concatenated = beach.concatenate(
| ... bird, mode='resample-off-axis', resample_kwargs=resample_kwargs
| ... )
| >>> concatenated.dimensions
| (558, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'resample-match'`` to resample all dimensions to match the input exactly. This
| option may also distort the image.
|
| >>> concatenated = beach.concatenate(
| ... bird, mode='resample-match', resample_kwargs=resample_kwargs
| ... )
| >>> concatenated.dimensions
| (200, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use the ``'preserve-extents'`` mode. Using this mode naively may not produce the
| desired result, e.g. if we concatenate ``beach`` with ``bird``, the ``beach`` image is
| completely overwritten since their :attr:`~pyvista.ImageData.extent` fully overlap.
|
| >>> beach.extent
| (0, 99, 0, 99, 0, 0)
| >>> bird.extent
| (0, 457, 0, 341, 0, 0)
|
| >>> concatenated = beach.concatenate(bird, mode='preserve-extents')
| >>> concatenated.extent
| (0, 457, 0, 341, 0, 0)
| >>> concatenated.plot(**plot_kwargs)
|
| Set the ``beach`` :attr:`~pyvista.ImageData.offset` so that there is only partial
| overlap instead.
|
| >>> beach.offset = (-50, -50, 0)
| >>> beach.extent
| (-50, 49, -50, 49, 0, 0)
|
| >>> concatenated = beach.concatenate(bird, mode='preserve-extents')
| >>> concatenated.extent
| (-50, 457, -50, 341, 0, 0)
| >>> concatenated.plot(**plot_kwargs)
|
| Reverse the concatenation order, and use a green background value.
|
| >>> green = pv.Color('green').int_rgb
| >>> concatenated = bird.concatenate(
| ... beach, mode='preserve-extents', background_value=green
| ... )
| >>> concatenated.extent
| (-50, 457, -50, 341, 0, 0)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'crop-off-axis'`` to only crop off-axis dimensions.
|
| >>> concatenated = beach.concatenate(bird, mode='crop-off-axis')
| >>> concatenated.dimensions
| (558, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Reverse the concatenation order.
|
| >>> concatenated = bird.concatenate(beach, mode='crop-off-axis')
| >>> concatenated.dimensions
| (558, 342, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'crop-match'`` to center-crop the images to match the input's
| dimensions.
|
| >>> concatenated = beach.concatenate(bird, mode='crop-match')
| >>> concatenated.dimensions
| (200, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Reverse the concatenation order, and use a grey background value.
|
| >>> concatenated = bird.concatenate(
| ... beach, mode='crop-match', background_value=128
| ... )
| >>> concatenated.dimensions
| (558, 342, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Load a binary image: :func:`~pyvista.examples.downloads.download_yinyang()`.
|
| >>> yinyang = examples.download_yinyang()
|
| Use ``component_policy`` to concatenate grayscale images with RGB(A) images.
|
| >>> concatenated = yinyang.concatenate(
| ... beach, mode='resample-proportional', component_policy='promote_rgba'
| ... )
| >>> concatenated.plot(**plot_kwargs)
|
| The grayscale portion of the image is promoted to RGB in this case and the entire
| image has 3 components:
|
| >>> concatenated.active_scalars.shape
| (292068, 3)
|
| contour_labeled(self, n_labels: 'int | None' = None, smoothing: 'bool' = False, smoothing_num_iterations: 'int' = 50, smoothing_relaxation_factor: 'float' = 0.5, smoothing_constraint_distance: 'float' = 1, output_mesh_type: "Literal['quads', 'triangles']" = 'quads', output_style: "Literal['default', 'boundary']" = 'default', scalars: 'str | None' = None, progress_bar: 'bool' = False) -> 'pv.PolyData'
| Generate labeled contours from 3D label maps.
|
| SurfaceNets algorithm is used to extract contours preserving sharp
| boundaries for the selected labels from the label maps.
| Optionally, the boundaries can be smoothened to reduce the staircase
| appearance in case of low resolution input label maps.
|
| This filter requires that the :class:`ImageData` has integer point
| scalars, such as multi-label maps generated from image segmentation.
|
| .. note::
| Requires ``vtk>=9.3.0``.
|
| .. deprecated:: 0.45
| This filter produces unexpected results and is deprecated.
| Use :meth:`~pyvista.ImageDataFilters.contour_labels` instead.
| See https://github.com/pyvista/pyvista/issues/5981 for details.
|
| To replicate the default behavior from this filter, call `contour_labels`
| with the following arguments:
|
| .. code-block:: python
|
| image.contour_labels(
| boundary_style='strict_external', # old filter strictly uses external polygons
| smoothing=False, # old filter does not apply smoothing
| output_mesh_type='quads', # old filter generates quads
| pad_background=False, # old filter generates open surfaces at input edges
| orient_faces=False, # old filter does not orient faces
| simplify_output=False, # old filter returns multi-component scalars
| )
|
| Parameters
| ----------
| n_labels : int, optional
| Number of labels to be extracted (all are extracted if None is given).
|
| smoothing : bool, default: False
| Apply smoothing to the meshes.
|
| smoothing_num_iterations : int, default: 50
| Number of smoothing iterations.
|
| smoothing_relaxation_factor : float, default: 0.5
| Relaxation factor of the smoothing.
|
| smoothing_constraint_distance : float, default: 1
| Constraint distance of the smoothing.
|
| output_mesh_type : str, default: 'quads'
| Type of the output mesh. Must be either ``'quads'``, or ``'triangles'``.
|
| output_style : str, default: 'default'
| Style of the output mesh. Must be either ``'default'`` or ``'boundary'``.
| When ``'default'`` is specified, the filter produces a mesh with both
| interior and exterior polygons. When ``'boundary'`` is selected, only
| polygons on the border with the background are produced (without interior
| polygons). Note that style ``'selected'`` is currently not implemented.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| :class:`pyvista.PolyData` Labeled mesh with the segments labeled.
|
| References
| ----------
| Sarah F. Frisken, SurfaceNets for Multi-Label Segmentations with Preservation
| of Sharp Boundaries, Journal of Computer Graphics Techniques (JCGT), vol. 11,
| no. 1, 34-54, 2022. Available online http://jcgt.org/published/0011/01/03/
|
| https://www.kitware.com/really-fast-isocontouring/
|
| Examples
| --------
| See :ref:`contouring_example` for a full example using this filter.
|
| See Also
| --------
| pyvista.DataSetFilters.contour
| Generalized contouring method which uses MarchingCubes or FlyingEdges.
|
| pyvista.DataSetFilters.pack_labels
| Function used internally by SurfaceNets to generate contiguous label data.
|
| contour_labels(self: 'ImageData', boundary_style: "Literal['external', 'internal', 'all', 'strict_external']" = 'external', *, background_value: 'int' = 0, select_inputs: 'int | VectorLike[int] | None' = None, select_outputs: 'int | VectorLike[int] | None' = None, pad_background: 'bool' = True, output_mesh_type: "Literal['quads', 'triangles'] | None" = None, scalars: 'str | None' = None, orient_faces: 'bool | None' = None, simplify_output: 'bool | None' = None, smoothing: 'bool' = True, smoothing_iterations: 'int' = 16, smoothing_relaxation: 'float' = 0.5, smoothing_distance: 'float | None' = None, smoothing_scale: 'float' = 1.0, progress_bar: 'bool' = False) -> 'PolyData'
| Generate surface contours from 3D image label maps.
|
| This filter uses :vtk:`vtkSurfaceNets3D`
| to extract polygonal surface contours from non-continuous label maps, which
| corresponds to discrete regions in an input 3D image (i.e., volume). It is
| designed to generate surfaces from image point data, e.g. voxel point
| samples from 3D medical images, though images with cell data are also supported.
|
| The generated surface is smoothed using a constrained smoothing filter, which
| may be fine-tuned to control the smoothing process. Optionally, smoothing may
| be disabled to generate a staircase-like surface.
|
| The output surface includes a two-component cell data array ``'boundary_labels'``.
| The array indicates the labels/regions on either side of the polygons composing
| the output. The array's values are structured as follows:
|
| External boundary values
|
| Polygons between a foreground region and the background have the
| form ``[foreground, background]``.
|
| E.g. ``[1, 0]`` for the boundary between region ``1`` and background ``0``.
|
| Internal boundary values
|
| Polygons between two connected foreground regions are sorted in ascending order.
|
| E.g. ``[1, 2]`` for the boundary between regions ``1`` and ``2``.
|
| By default, this filter returns ``'external'`` contours only. Optionally,
| only the ``'internal'`` contours or ``'all'`` contours (i.e. internal and
| external) may be returned.
|
| .. note::
|
| This filter requires VTK version ``9.3.0`` or greater.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| boundary_style : 'external' | 'internal' | 'all' | 'strict_external', default: 'external'
| Style of boundary polygons to generate. ``'internal'`` polygons are generated
| between two connected foreground regions. ``'external'`` polygons are
| generated between foreground and background regions. ``'all'`` includes
| both internal and external boundary polygons.
|
| These styles are generated such that ``internal + external = all``.
| Internally, the filter computes all boundary polygons by default and
| then removes any undesired polygons in post-processing.
| This improves the quality of the output, but can negatively affect the
| filter's performance since all boundaries are always initially computed.
|
| The ``'strict_external'`` style can be used as a fast alternative to
| ``'external'``. This style `strictly` generates external polygons and does
| not compute or consider internal boundaries. This computation is fast, but
| also results in jagged, non-smooth boundaries between regions. The
| ``select_inputs`` and ``select_outputs`` options cannot be used with this
| style.
|
| background_value : int, default: 0
| Background value of the input image. All other values are considered
| as foreground.
|
| select_inputs : int | VectorLike[int], default: None
| Specify label ids to include as inputs to the filter. Labels that are not
| selected are removed from the input *before* generating the surface. By
| default, all label ids are used.
|
| Since the smoothing operation occurs across selected input regions, using
| this option to filter the input can result in smoother and more visually
| pleasing surfaces since non-selected inputs are not considered during
| smoothing. However, this also means that the generated surface will change
| shape depending on which inputs are selected.
|
| .. note::
|
| Selecting inputs can affect whether a boundary polygon is considered to
| be ``internal`` or ``external``. That is, an internal boundary becomes an
| external boundary when only one of the two foreground regions on the
| boundary is selected.
|
| select_outputs : int | VectorLike[int], default: None
| Specify label ids to include in the output of the filter. Labels that are
| not selected are removed from the output *after* generating the surface. By
| default, all label ids are used.
|
| Since the smoothing operation occurs across all input regions, using this
| option to filter the output means that the selected output regions will have
| the same shape (i.e. smoothed in the same manner), regardless of the outputs
| that are selected. This is useful for generating a surface for specific
| labels while also preserving sharp boundaries with non-selected outputs.
|
| .. note::
|
| Selecting outputs does not affect whether a boundary polygon is
| considered to be ``internal`` or ``external``. That is, an internal
| boundary remains internal even if only one of the two foreground regions
| on the boundary is selected.
|
| pad_background : bool, default: True
| :meth:`Pad <pyvista.ImageDataFilters.pad_image>` the image
| with ``background_value`` prior to contouring. This will
| generate polygons to "close" the surface at the boundaries of the image.
| This option is only relevant when there are foreground regions on the border
| of the image. Setting this value to ``False`` is useful if processing multiple
| volumes separately so that the generated surfaces fit together without
| creating surface overlap.
|
| output_mesh_type : str, default: None
| Type of the output mesh. Can be either ``'quads'``, or ``'triangles'``. By
| default, the output mesh has :attr:`~pyvista.CellType.TRIANGLE` cells when
| ``smoothing`` is enabled and :attr:`~pyvista.CellType.QUAD` cells (quads)
| otherwise. The mesh type can be forced to be triangles or quads; however,
| if smoothing is enabled and the type is ``'quads'``, the generated quads
| may not be planar.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars. If cell
| scalars are specified, the input image is first re-meshed with
| :meth:`~pyvista.ImageDataFilters.cells_to_points` to transform the cell
| data into point data.
|
| orient_faces : bool, optional
| .. deprecated:: 0.47
|
| This keyword should not be used and will be removed in a future version. It was
| meant to address a vtk bug where the faces generated by :vtk:`vtkSurfaceNets3D`
| have incorrect orientation. This bug is fixed in VTK 9.6, and therefore the faces
| now always have correct orientation by default.
|
| Orient the faces of the generated contours so that they have consistent
| ordering and face outward. If ``False``, the generated polygons may have
| inconsistent ordering and orientation, which can negatively impact
| downstream calculations and the shading used for rendering.
|
| .. note::
|
| Orienting the faces can be computationally expensive for large meshes.
| Consider disabling this option to improve this filter's performance.
|
| .. warning::
|
| Enabling this option is `likely` to generate surfaces with normals
| pointing outward when ``pad_background`` is ``True`` and
| ``boundary_style`` is ``'external'`` (the default). However, this is
| not guaranteed if the generated surface is not closed or if internal
| boundaries are generated. Do not assume the normals will point outward
| in all cases.
|
| simplify_output : bool, optional
| Simplify the ``'boundary_labels'`` array as a single-component 1D array.
| If ``False``, the returned ``'boundary_labels'`` array is a two-component
| 2D array. This simplification is useful when only external boundaries
| are generated and/or when visualizing internal boundaries. The
| simplification is as follows:
|
| - External boundaries are simplified by keeping the first component and
| removing the second. Since external polygons may only share a boundary
| with the background, the second component is always ``background_value``
| and therefore can be dropped without loss of information. The values
| of external boundaries always match the foreground values of the input.
|
| - Internal boundaries are simplified by assigning them unique negative
| values sequentially. E.g. the boundary label ``[1, 2]`` is replaced with
| ``-1``, ``[1, 3]`` is replaced with ``-2``, etc. The mapping to negative
| values is not fixed, and can change depending on the input.
|
| This simplification is particularly useful for unsigned integer labels
| (e.g. scalars with ``'uint8'`` dtype) since external boundaries
| will be positive and internal boundaries will be negative in this case.
|
| By default, the output is simplified when ``boundary_type`` is
| ``'external'`` or ``'strict_external'``, and is not simplified otherwise.
|
| smoothing : bool, default: True
| Smooth the generated surface using a constrained smoothing filter. Each
| point in the surface is smoothed as follows:
|
| For a point ``pi`` connected to a list of points ``pj`` via an edge, ``pi``
| is moved towards the average position of ``pj`` multiplied by the
| ``smoothing_relaxation`` factor, and limited by the ``smoothing_distance``
| constraint. This process is repeated either until convergence occurs, or
| the maximum number of ``smoothing_iterations`` is reached.
|
| smoothing_iterations : int, default: 16
| Maximum number of smoothing iterations to use.
|
| smoothing_relaxation : float, default: 0.5
| Relaxation factor used at each smoothing iteration.
|
| smoothing_distance : float, default: None
| Maximum distance each point is allowed to move (in any direction) during
| smoothing. This distance may be scaled with ``smoothing_scale``. By default,
| the distance is computed dynamically from the image spacing as:
|
| ``distance = norm(image_spacing) * smoothing_scale``.
|
| smoothing_scale : float, default: 1.0
| Relative scaling factor applied to ``smoothing_distance``. See that
| parameter for details.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of labeled regions.
|
| See Also
| --------
| :meth:`~pyvista.DataSetFilters.voxelize_binary_mask`
| Filter that generates binary labeled :class:`~pyvista.ImageData` from
| :class:`~pyvista.PolyData` surface contours. Can beloosely considered as
| an inverse of this filter.
|
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter which can used to process the multi-component
| scalars generated by this filter.
|
| :meth:`~pyvista.DataSetFilters.contour`
| Generalized contouring method which uses MarchingCubes or FlyingEdges.
|
| :meth:`~pyvista.DataSetFilters.pack_labels`
| Function used internally by SurfaceNets to generate contiguous label data.
|
| :meth:`~pyvista.DataSetFilters.color_labels`
| Color labeled data, e.g. labeled volumes or contours.
|
| :ref:`contouring_example`, :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| References
| ----------
| S. Frisken, SurfaceNets for Multi-Label Segmentations with Preservation of
| Sharp Boundaries, J. Computer Graphics Techniques, 2022. Available online:
| http://jcgt.org/published/0011/01/03/
|
| W. Schroeder, S. Tsalikis, M. Halle, S. Frisken. A High-Performance SurfaceNets
| Discrete Isocontouring Algorithm. arXiv:2401.14906. 2024. Available online:
| `http://arxiv.org/abs/2401.14906 <http://arxiv.org/abs/2401.14906>`__
|
| Examples
| --------
| Load labeled image data with a background region ``0`` and four foreground
| regions.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> label_ids = np.unique(image.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
| >>> image.dimensions
| (251, 251, 101)
|
| Crop the image to simplify the data.
|
| >>> image = image.extract_subset(voi=(75, 109, 75, 109, 85, 100))
| >>> image.dimensions
| (35, 35, 16)
|
| Plot the cropped image for context. Use :meth:`~pyvista.DataSetFilters.color_labels`
| to generate consistent coloring of the regions for all plots. Negative indexing
| is used for plotting internal boundaries.
|
| >>> def labels_plotter(mesh, zoom=None):
| ... colored_mesh = mesh.color_labels(negative_indexing=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored_mesh, show_edges=True)
| ... if zoom:
| ... pl.camera.zoom(zoom)
| ... return pl
| >>>
| >>> labels_plotter(image).show()
|
| Generate surface contours of the foreground regions and plot it. Note that
| the ``background_value`` is ``0`` by default.
|
| >>> contours = image.contour_labels()
| >>> labels_plotter(contours, zoom=1.5).show()
|
| By default, only external boundary polygons are generated and the returned
| ``'boundary_labels'`` array is a single-component array. The output values
| match the input label values.
|
| >>> contours['boundary_labels'].ndim
| 1
| >>> np.unique(contours['boundary_labels'])
| pyvista_ndarray([1, 2, 3, 4])
|
| Set ``simplify_output`` to ``False`` to generate a two-component
| array instead showing the two boundary regions associated with each polygon.
|
| >>> contours = image.contour_labels(simplify_output=False)
| >>> contours['boundary_labels'].ndim
| 2
|
| Show the unique values. Since only ``'external'`` boundaries are generated
| by default, the second component is always ``0`` (i.e. the ``background_value``).
| Note that all four foreground regions share a boundary with the background.
|
| >>> np.unique(contours['boundary_labels'], axis=0)
| array([[1, 0],
| [2, 0],
| [3, 0],
| [4, 0]])
|
| Repeat the example but this time generate internal contours only. The generated
| array is 2D by default.
|
| >>> contours = image.contour_labels('internal')
| >>> contours['boundary_labels'].ndim
| 2
|
| Show the unique two-component boundary labels again. From these values we can
| determine that all foreground regions share an internal boundary with each
| other `except` for regions ``1`` and ``3`` since the boundary value ``[1, 3]``
| is missing.
|
| >>> np.unique(contours['boundary_labels'], axis=0)
| array([[1, 2],
| [1, 4],
| [2, 3],
| [2, 4],
| [3, 4]])
|
| Simplify the output so that each internal multi-component boundary value is
| assigned a unique negative integer value instead. This makes it easier to
| visualize the result with :meth:`~pyvista.DataSetFilters.color_labels` using
| the ``negative_indexing`` option.
|
| >>> contours = image.contour_labels('internal', simplify_output=True)
| >>> contours['boundary_labels'].ndim
| 1
| >>> np.unique(contours['boundary_labels'])
| pyvista_ndarray([-5, -4, -3, -2, -1])
|
| >>> labels_plotter(contours, zoom=1.5).show()
|
| Generate contours for all boundaries, and use ``select_outputs`` to filter
| the output to only include polygons which share a boundary with region ``3``.
|
| >>> region_3 = image.contour_labels(
| ... 'all', select_outputs=3, simplify_output=True
| ... )
| >>> labels_plotter(region_3, zoom=3).show()
|
| Note how using ``select_outputs`` preserves the sharp features and boundary
| labels for non-selected regions. If desired, use ``select_inputs`` instead to
| completely "ignore" non-selected regions.
|
| >>> region_3 = image.contour_labels(select_inputs=3)
| >>> labels_plotter(region_3, zoom=3).show()
|
| The sharp features are now smoothed and the internal boundaries are now labeled
| as external boundaries. Note that using ``'all'`` here is optional since
| using ``select_inputs`` converts previously-internal boundaries into external
| ones.
|
| Do not pad the image with background values before contouring. Since the input image
| has foreground regions visible at the edges of the image (e.g. the ``+Z`` bound),
| setting ``pad_background=False`` in this example causes the top and sides of
| the mesh to be "open".
|
| >>> surf = image.contour_labels(pad_background=False)
| >>> labels_plotter(surf, zoom=1.5).show()
|
| Disable smoothing to generate staircase-like surface. Without smoothing, the
| surface has quadrilateral cells by default.
|
| >>> surf = image.contour_labels(smoothing=False)
| >>> labels_plotter(surf, zoom=1.5).show()
|
| Keep smoothing enabled but reduce the smoothing scale. A smoothing scale
| less than one may help preserve sharp features (e.g. corners).
|
| >>> surf = image.contour_labels(smoothing_scale=0.5)
| >>> labels_plotter(surf, zoom=1.5).show()
|
| Use the ``'strict_external'`` style to compute external contours quickly. Note
| that this produces jagged and non-smooth boundaries between regions, which may
| not be desirable. Also note how the top of the surface is perfectly flat compared
| to the default ``'external'`` style (see first example above) since the strict
| style ignores the smoothing effects of all internal boundaries.
|
| >>> surf = image.contour_labels('strict_external')
| >>> labels_plotter(surf, zoom=1.5).show()
|
| crop(self: 'ImageData', *, factor: 'float | VectorLike[float] | None' = None, margin: 'int | VectorLike[int] | None' = None, offset: 'VectorLike[int] | None' = None, dimensions: 'VectorLike[int] | None' = None, extent: 'VectorLike[int] | None' = None, normalized_bounds: 'VectorLike[float] | None' = None, mask: 'str | ImageData | NumpyArray[float] | Literal[True] | None' = None, padding: 'int | VectorLike[int] | None' = None, background_value: 'float | None' = None, keep_dimensions: 'bool' = False, fill_value: 'float | VectorLike[float] | None' = None, rebase_coordinates: 'bool' = False, progress_bar: 'bool' = False) -> 'ImageData'
| Crop this image to remove points at its boundaries.
|
| This filter is useful for extracting a volume or region of interest. There are several ways
| to crop:
|
| #. Use ``factor`` to crop a portion of the image symmetrically.
| #. Use ``margin`` to remove points from the image border.
| #. Use ``dimensions`` (and optionally, ``offset``) to explicitly crop to the specified
| :attr:`~pyvista.ImageData.dimensions` and :attr:`~pyvista.ImageData.offset`.
| #. Use ``extent`` to explicitly crop to a specified :attr:`~pyvista.ImageData.extent`.
| #. Use ``normalized_bounds`` to crop a bounding box relative to the input size.
| #. Use ``mask``, ``padding``, and ``background_value`` to crop to this mesh using scalar
| values to define the cropping region.
|
| These methods are all independent, e.g. it is not possible to specify both ``factor`` and
| ``margin``.
|
| By default, the cropped output's :attr:`~pyvista.ImageData.dimensions` are typically less
| than the input's dimensions. Optionally, use ``keep_dimensions`` and ``fill_value`` to
| ensure the output dimensions always match the input.
|
| .. note::
|
| All cropping is performed using the image's ijk-indices, not physical xyz-bounds.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| factor : float, optional
| Cropping factor in range ``[0.0, 1.0]`` which specifies the proportion of the image to
| keep along each axis. Use a single float for uniform cropping or a vector of three
| floats for cropping each xyz-axis independently. The crop is centered in the image.
|
| margin : int | VectorLike[int], optional
| Margin to remove from each side of each axis. Specify:
|
| - A single value to remove from all boundaries equally.
| - Two values, one for each ``(X, Y)`` axis, to remove margin from
| each axis independently.
| - Three values, one for each ``(X, Y, Z)`` axis, to remove margin from
| each axis independently.
| - Four values, one for each ``(-X, +X, -Y, +Y)`` boundary, to remove
| margin from each boundary independently.
| - Six values, one for each ``(-X, +X, -Y, +Y, -Z, +Z)`` boundary, to remove
| margin from each boundary independently.
|
| offset : VectorLike[int], optional
| Length-3 vector of integers specifying the :attr:`~pyvista.ImageData.offset` indices
| where the cropping region originates. If specified, then ``dimensions`` must also be
| provided.
|
| dimensions : VectorLike[int], optional
| Length-3 vector of integers specifying the :attr:`~pyvista.ImageData.dimensions` of
| the cropping region. ``offset`` may also be provided, but if it is not, the crop is
| centered in the image.
|
| extent : VectorLike[int], optional
| Length-6 vector of integers specifying the full :attr:`~pyvista.ImageData.extent` of
| the cropping region.
|
| normalized_bounds : VectorLike[float], optional
| Normalized bounds relative to the input. These are floats between ``0.0`` and ``1.0``
| that define a box relative to the input size. The input is cropped such that it fully
| fits within these bounds. Has the form ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| mask : str | ImageData | NumpyArray[float] | bool, optional
| Scalar values that define the cropping region. Set this option to:
|
| - a string denoting the name of scalars belonging to this mesh
| - ``True`` to use this mesh's default scalars
| - a separate image, in which case the other image's active scalars are used
| - a 1D or 2D (multi-component) array
|
| The length of the scalar array must equal the number of points.
|
| This mesh will be cropped to the bounds of the foreground values of the array, i.e.
| values that are not equal to the specified ``background_value``.
|
| padding : int | VectorLike[int], optional
| Padding to add to foreground region `before` cropping. Only valid when using a mask to
| crop the image. Specify:
|
| - A single value to pad all boundaries equally.
| - Two values, one for each ``(X, Y)`` axis, to apply symmetric padding to
| each axis independently.
| - Three values, one for each ``(X, Y, Z)`` axis, to apply symmetric padding
| to each axis independently.
| - Four values, one for each ``(-X, +X, -Y, +Y)`` boundary, to apply
| padding to each boundary independently.
| - Six values, one for each ``(-X, +X, -Y, +Y, -Z, +Z)`` boundary, to apply
| padding to each boundary independently.
|
| The specified value is the `maximum` padding that may be applied. If the padding
| extends beyond the actual extents of this mesh, it is clipped and does not extend
| outside the bounds of the image.
|
| background_value : float | VectorLike[float], optional
| Value or multi-component vector considered to be the background. Only valid when using
| a mask to crop the image.
|
| keep_dimensions : bool, default: False
| If ``True``, the cropped output is :meth:`padded <pad_image>` with ``fill_value`` to
| ensure the output dimensions match the input.
|
| fill_value : float | VectorLike[float], optional
| Value used when padding the cropped output if ``keep_dimensions`` is ``True``. May be
| a single float or a multi-component vector (e.g. RGB vector).
|
| rebase_coordinates : bool, default: False
| Rebase the coordinate reference of the cropped output:
|
| - the :attr:`~pyvista.ImageData.origin` is set to the minimum bounds of the subset
| - the :attr:`~pyvista.ImageData.offset` is reset to ``(0, 0, 0)``
|
| The rebasing effectively applies a positive translation in world (XYZ) coordinates and
| a similar (i.e. inverse) negative translation in voxel (IJK) coordinates. As a result,
| the :attr:`~pyvista.DataSet.bounds` of the output are unchanged, but the coordinate
| reference frame is modified.
|
| Set this to ``False`` to leave the origin unmodified and keep the offset used by the
| crop.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Cropped image.
|
| See Also
| --------
| pad_image
| Add points to image boundaries. This is the inverse operation of the ``margin`` crop.
|
| resample
| Modify an image's dimensions and spacing.
|
| select_values
| Threshold-like filter which may be used to generate a mask for cropping.
|
| extract_subset
| Equivalent filter to ``crop(extent=voi, rebase_coordinates=True)``.
|
| :ref:`crop_labeled_example`
| Example cropping :class:`~pyvista.ImageData` using a segmentation mask.
|
| Examples
| --------
| Load a grayscale image.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> gray_image = examples.download_yinyang()
| >>> gray_image.dimensions
| (512, 342, 1)
|
| Define a custom plotting helper to show the image as pixel cells.
|
| >>> def image_plotter(image):
| ... pixel_cells = image.points_to_cells()
| ...
| ... pl = pv.Plotter()
| ... pl.add_mesh(
| ... pixel_cells,
| ... cmap='gray',
| ... clim=[0, 255],
| ... lighting=False,
| ... show_scalar_bar=False,
| ... )
| ... pl.view_xy()
| ... pl.camera.tight()
| ... return pl
|
| Plot the image for context.
|
| >>> image_plotter(gray_image).show()
|
| Crop the white border around the image using active scalars as a mask. Here we specify a
| background value of ``255`` to correspond to white pixels. If this was an RGB image, we
| could also specify ``(255, 255, 255)`` as the background value.
|
| >>> cropped = gray_image.crop(mask=True, background_value=255)
| >>> cropped.dimensions
| (237, 238, 1)
| >>> image_plotter(cropped).show()
|
| Use ``margin`` instead to remove 100 and 20 pixels from each side of the x- and y-axis,
| respectively.
|
| >>> cropped = gray_image.crop(margin=(100, 20))
| >>> cropped.dimensions
| (312, 302, 1)
| >>> image_plotter(cropped).show()
|
| Use ``offset`` to select a starting location for the crop (from the origin at the
| bottom-left corner) along with ``dimensions`` to define the crop size.
|
| >>> cropped = gray_image.crop(offset=(50, 20, 0), dimensions=(300, 200, 1))
| >>> cropped.dimensions
| (300, 200, 1)
| >>> image_plotter(cropped).show()
|
| Use ``extent`` directly instead of using ``dimensions`` and ``offset`` to yield the same
| result as above.
|
| >>> cropped = gray_image.crop(extent=(50, 349, 20, 219, 0, 0))
| >>> cropped.extent
| (50, 349, 20, 219, 0, 0)
| >>> image_plotter(cropped).show()
|
| Use ``factor`` to crop 40% of the image. This `keeps` 40% of the pixels along each axis,
| and `removes` 60% (i.e. 30% from each side).
|
| >>> cropped = gray_image.crop(factor=0.4)
| >>> cropped.dimensions
| (204, 136, 1)
| >>> image_plotter(cropped).show()
|
| Use ``normalized_bounds`` to crop from 40% to 80% of the image along the x-axis, and
| from 30% to 90% of the image along the y-axis.
|
| >>> cropped = gray_image.crop(normalized_bounds=[0.4, 0.8, 0.3, 0.9, 0.0, 1.0])
| >>> cropped.extent
| (205, 408, 103, 306, 0, 0)
| >>> image_plotter(cropped).show()
|
| dilate(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Morphologically dilate grayscale or binary data.
|
| This filter may be used to dilate grayscale images with continuous data, binary images
| with a single background and foreground value, or multi-label images.
|
| For binary inputs with two unique values, this filter uses :vtk:`vtkImageDilateErode3D`
| by default to perform fast binary dilation over an ellipsoidal neighborhood. Otherwise,
| the slower class :vtk:`vtkImageContinuousDilate3D` is used to perform generalized grayscale
| dilation by replacing each pixel with the maximum over an ellipsoidal neighborhood.
|
| Optionally, the ``binary`` keyword may be used to explicitly control the behavior of the
| filter.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are dilated, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary dilation or continuous dilation is used.
|
| If set, :vtk:`vtkImageDilateErode3D` is used to strictly dilate with two values.
| Set this to ``True`` to dilate the maximum value in ``scalars`` with its minimum value,
| or set it to two values ``[background_value, foreground_value]`` to dilate
| ``foreground_value`` with ``background_value`` explicitly.
|
| Set this to ``False`` to use :vtk:`vtkImageContinuousDilate3D` to perform continuous
| dilation.
|
| By default, ``binary`` is ``True`` if the input has two unique values, and ``False``
| otherwise.
|
| .. note::
| - If the input is a binary mask, setting ``binary=True`` produces the same output
| as ``binary=False``, but the filter is much more performant.
| - Setting ``binary=[background_value, foreground_value]`` is useful to `isolate`
| the dilation to two values, e.g. for multi-label segmentation masks.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been dilated.
|
| See Also
| --------
| erode, open, close
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| .. pyvista-plot::
| :force_static:
|
| Create a toy example with two non-zero grayscale foreground values
| :meth:`padded <pad_image>` with a background of zeros.
|
| >>> import pyvista as pv
| >>> im = pv.ImageData(dimensions=(2, 1, 1))
| >>> im['data'] = [128, 255]
| >>> im = im.pad_image(pad_value=0, pad_size=2, dimensionality=2)
|
| Define a custom plotter to plot pixels as cells.
|
| >>> def image_plotter(image):
| ... pl = pv.Plotter()
| ... pl.add_mesh(
| ... image.points_to_cells(),
| ... cmap='grey',
| ... clim=[0, 255],
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... lighting=False,
| ... line_width=3,
| ... )
| ... pl.camera_position = 'xy'
| ... pl.camera.tight()
| ... pl.enable_anti_aliasing()
| ... return pl
|
| Show the image.
|
| >>> image_plotter(im).show()
|
| Dilate it with default settings. Observe that `both` foreground values are dilated.
|
| >>> dilated = im.dilate()
| >>> image_plotter(dilated).show()
|
| Use a larger kernel size.
|
| >>> dilated = im.dilate(kernel_size=5)
| >>> image_plotter(dilated).show()
|
| Use an asymmetric kernel.
|
| >>> dilated = im.dilate(kernel_size=(2, 4, 1))
| >>> image_plotter(dilated).show()
|
| Use binary dilation. By default, the max value (``255`` in this example) is dilated
| with the min value (``0`` in this example). All other values are unaffected.
|
| >>> dilated = im.dilate(binary=True)
| >>> image_plotter(dilated).show()
|
| Equivalently, set the binary values for the dilation explicitly.
|
| >>> dilated = im.dilate(binary=[0, 255])
| >>> image_plotter(dilated).show()
|
| Use binary dilation with the other foreground value instead.
|
| >>> dilated = im.dilate(binary=[0, 128])
| >>> image_plotter(dilated).show()
|
| erode(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Morphologically erode grayscale or binary data.
|
| This filter may be used to erode grayscale images with continuous data, binary images
| with a single background and foreground value, or multi-label images.
|
| For binary inputs with two unique values, this filter uses :vtk:`vtkImageDilateErode3D`
| by default to perform fast binary erosion over an ellipsoidal neighborhood. Otherwise,
| the slower class :vtk:`vtkImageContinuousErode3D` is used to perform generalized grayscale
| erosion by replacing each pixel with the minimum over an ellipsoidal neighborhood.
|
| Optionally, the ``binary`` keyword may be used to explicitly control the behavior of the
| filter.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are eroded, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary erosion or continuous erosion is used.
|
| If set, :vtk:`vtkImageDilateErode3D` is used to strictly erode with two values.
| Set this to ``True`` to erode the maximum value in ``scalars`` with its minimum value,
| or set it to two values ``[background_value, foreground_value]`` to erode
| ``foreground_value`` with ``background_value`` explicitly.
|
| Set this to ``False`` to use :vtk:`vtkImageContinuousErode3D` to perform continuous
| erosion.
|
| By default, ``binary`` is ``True`` if the input has two unique values, and ``False``
| otherwise.
|
| .. note::
| - If the input is a binary mask, setting ``binary=True`` produces the same output
| as ``binary=False``, but the filter is much more performant.
| - Setting ``binary=[background_value, foreground_value]`` is useful to `isolate`
| the erosion to two values, e.g. for multi-label segmentation masks.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been eroded.
|
| See Also
| --------
| dilate, open, close
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| .. pyvista-plot::
| :force_static:
|
| Create a toy example with two non-zero grayscale foreground regions
| using :meth:`pad_image`.
|
| >>> import pyvista as pv
| >>> # Create an initial background point
| >>> im = pv.ImageData(dimensions=(1, 1, 1))
| >>> im['data'] = [0]
| >>> # Add a foreground region
| >>> im = im.pad_image(pad_value=255, pad_size=(4, 3), dimensionality=2)
| >>> # Add a second foreground region
| >>> im = im.pad_image(pad_value=128, pad_size=(2, 0, 1, 0))
| >>> # Add background values to two sides
| >>> im = im.pad_image(pad_value=0, pad_size=(1, 0))
|
| Define a custom plotter to plot pixels as cells.
|
| >>> def image_plotter(image):
| ... pl = pv.Plotter()
| ... pl.add_mesh(
| ... image.points_to_cells(),
| ... cmap='grey',
| ... clim=[0, 255],
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... lighting=False,
| ... line_width=3,
| ... )
| ... pl.camera_position = 'xy'
| ... pl.camera.tight()
| ... pl.enable_anti_aliasing()
| ... return pl
|
| Show the image.
|
| >>> image_plotter(im).show()
|
| Erode it with default settings. Observe that `both` foreground values are eroded.
|
| >>> eroded = im.erode()
| >>> image_plotter(eroded).show()
|
| Use a larger kernel size.
|
| >>> eroded = im.erode(kernel_size=5)
| >>> image_plotter(eroded).show()
|
| Use an asymmetric kernel.
|
| >>> eroded = im.erode(kernel_size=(2, 4, 1))
| >>> image_plotter(eroded).show()
|
| Use binary erosion. By default, the max value (``255`` in this example) is eroded
| with the min value (``0`` in this example). All other values are unaffected.
|
| >>> eroded = im.erode(binary=True)
| >>> image_plotter(eroded).show()
|
| Equivalently, set the binary values for the erosion explicitly.
|
| >>> eroded = im.erode(binary=[0, 255])
| >>> image_plotter(eroded).show()
|
| Use binary erosion with the other foreground value instead.
|
| >>> eroded = im.erode(binary=[0, 128])
| >>> image_plotter(eroded).show()
|
| extract_subset(self, voi, rate=(1, 1, 1), boundary: 'bool' = False, rebase_coordinates: 'bool' = True, progress_bar: 'bool' = False)
| Select piece (e.g., volume of interest).
|
| To use this filter set the VOI ivar which are i-j-k min/max indices
| that specify a rectangular region in the data. (Note that these are
| 0-offset.) You can also specify a sampling rate to subsample the
| data.
|
| Typical applications of this filter are to extract a slice from a
| volume for image processing, subsampling large volumes to reduce data
| size, or extracting regions of a volume with interesting data.
|
| Parameters
| ----------
| voi : sequence[int]
| Length 6 iterable of ints: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| These bounds specify the volume of interest in i-j-k min/max
| indices.
|
| rate : sequence[int], default: (1, 1, 1)
| Length 3 iterable of ints: ``(xrate, yrate, zrate)``.
|
| boundary : bool, default: False
| Control whether to enforce that the "boundary" of the grid
| is output in the subsampling process. This only has effect
| when the rate in any direction is not equal to 1. When
| this is enabled, the subsampling will always include the
| boundary of the grid even though the sample rate is not an
| even multiple of the grid dimensions. By default this is
| disabled.
|
| rebase_coordinates : bool, default: True
| If ``True`` (default), reset the coordinate reference of the extracted subset:
|
| - the :attr:`~pyvista.ImageData.origin` is set to the minimum bounds of the subset
| - the :attr:`~pyvista.ImageData.offset` is reset to ``(0, 0, 0)``
|
| The rebasing effectively applies a positive translation in world (XYZ) coordinates and
| a similar (i.e. inverse) negative translation in voxel (IJK) coordinates. As a result,
| the :attr:`~pyvista.DataSet.bounds` of the output are unchanged, but the coordinate
| reference frame is modified.
|
| Set this to ``False`` to leave the origin unmodified and keep the offset specified by
| the ``voi`` parameter.
|
| .. versionadded:: 0.46
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| ImageData subset.
|
| See Also
| --------
| slice_index
| crop
|
| fft(self, output_scalars_name=None, progress_bar: 'bool' = False)
| Apply a fast Fourier transform (FFT) to the active scalars.
|
| The input can be real or complex data, but the output is always
| :attr:`numpy.complex128`. The filter is fastest for images that have
| power of two sizes.
|
| The filter uses a butterfly diagram for each prime factor of the
| dimension. This makes images with prime number dimensions (i.e. 17x17)
| much slower to compute. FFTs of multidimensional meshes (i.e volumes)
| are decomposed so that each axis executes serially.
|
| The frequencies of the output assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with applied FFT.
|
| See Also
| --------
| rfft : The reverse transform.
| low_pass : Low-pass filtering of FFT output.
| high_pass : High-pass filtering of FFT output.
|
| Examples
| --------
| Apply FFT to an example image.
|
| >>> from pyvista import examples
| >>> image = examples.download_moonlanding_image()
| >>> fft_image = image.fft()
| >>> fft_image.point_data # doctest:+SKIP
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : PNGImage
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| PNGImage complex128 (298620,) SCALARS
|
| See :ref:`image_fft_example` for a full example using this filter.
|
| gaussian_smooth(self, radius_factor=1.5, std_dev=2.0, scalars=None, progress_bar: 'bool' = False)
| Smooth the data with a Gaussian kernel.
|
| Parameters
| ----------
| radius_factor : float | sequence[float], default: 1.5
| Unitless factor to limit the extent of the kernel.
|
| std_dev : float | sequence[float], default: 2.0
| Standard deviation of the kernel in pixel units.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Uniform grid with smoothed scalars.
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| First, create sample data to smooth. Here, we use
| :func:`pyvista.perlin_noise() <pyvista.core.utilities.features.perlin_noise>`
| to create meaningful data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 5, 8), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1, 0, 1, 0, 1], dim=(20, 20, 20)
| ... )
| >>> grid.plot(show_scalar_bar=False)
|
| Next, smooth the sample data.
|
| >>> smoothed = grid.gaussian_smooth()
| >>> smoothed.plot(show_scalar_bar=False)
|
| See :ref:`gaussian_smoothing_example` for a full example using this filter.
|
| high_pass(self, x_cutoff, y_cutoff, z_cutoff, order=1, output_scalars_name=None, progress_bar: 'bool' = False)
| Perform a Butterworth high pass filter in the frequency domain.
|
| This filter requires that the :class:`ImageData` have a complex point
| scalars, usually generated after the :class:`ImageData` has been
| converted to the frequency domain by a :func:`ImageDataFilters.fft`
| filter.
|
| A :func:`ImageDataFilters.rfft` filter can be used to convert the
| output back into the spatial domain. This filter attenuates low
| frequency components. Input and output are complex arrays with
| datatype :attr:`numpy.complex128`.
|
| The frequencies of the input assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| x_cutoff : float
| The cutoff frequency for the x-axis.
|
| y_cutoff : float
| The cutoff frequency for the y-axis.
|
| z_cutoff : float
| The cutoff frequency for the z-axis.
|
| order : int, default: 1
| The order of the cutoff curve. Given from the equation
| ``1/(1 + (cutoff/freq(i, j))**(2*order))``.
|
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with the applied high pass filter.
|
| See Also
| --------
| fft : Direct fast Fourier transform.
| rfft : Reverse fast Fourier transform.
| low_pass : Low-pass filtering of FFT output.
|
| Examples
| --------
| See :ref:`image_fft_perlin_noise_example` for a full example using this filter.
|
| image_dilate_erode(self, dilate_value=1.0, erode_value=0.0, kernel_size=(3, 3, 3), scalars=None, progress_bar: 'bool' = False)
| Dilates one value and erodes another.
|
| .. deprecated:: 0.47.0
| :meth:`image_dilate_erode` is deprecated. Use :meth:`dilate`, :meth:`erode`,
| :meth:`open`, or :meth:`close` instead.
|
| ``image_dilate_erode`` will dilate one value and erode another. It uses
| an elliptical footprint, and only erodes/dilates on the boundary of the
| two values. The filter is restricted to the X, Y, and Z axes for now.
| It can degenerate to a 2 or 1-dimensional filter by setting the kernel
| size to 1 for a specific axis.
|
| Parameters
| ----------
| dilate_value : float, default: 1.0
| Dilate value in the dataset.
|
| erode_value : float, default: 0.0
| Erode value in the dataset.
|
| kernel_size : sequence[int], default: (3, 3, 3)
| Determines the size of the kernel along the three axes.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been dilated/eroded on the boundary of the specified scalars.
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| Demonstrate image dilate/erode on an example dataset. First, plot
| the example dataset with the active scalars.
|
| >>> from pyvista import examples
| >>> uni = examples.load_uniform()
| >>> uni.plot()
|
| Now, plot the image threshold with ``threshold=[400, 600]``. Note how
| values within the threshold are 1 and outside are 0.
|
| >>> ithresh = uni.image_threshold([400, 600])
| >>> ithresh.plot()
|
| Note how there is a hole in the thresholded image. Apply a closing
| filter with a large kernel to fill that hole in.
|
| >>> iclosed = ithresh.close(kernel_size=[5, 5, 5])
| >>> iclosed.plot()
|
| image_threshold(self: 'ImageData', threshold, in_value=1.0, out_value=0.0, scalars=None, preference='point', progress_bar: 'bool' = False)
| Apply a threshold to scalar values in a uniform grid.
|
| If a single value is given for threshold, scalar values above or equal
| to the threshold are ``'in'`` and scalar values below the threshold are ``'out'``.
| If two values are given for threshold (sequence) then values equal to
| or between the two values are ``'in'`` and values outside the range are ``'out'``.
|
| If ``None`` is given for ``in_value``, scalars that are ``'in'`` will not be replaced.
| If ``None`` is given for ``out_value``, scalars that are ``'out'`` will not be replaced.
|
| Warning: applying this filter to cell data will send the output to a
| new point array with the same name, overwriting any existing point data
| array with the same name.
|
| Parameters
| ----------
| threshold : float or sequence[float]
| Single value or (min, max) to be used for the data threshold. If
| a sequence, then length must be 2. Threshold(s) for deciding which
| cells/points are ``'in'`` or ``'out'`` based on scalar data.
|
| in_value : float, default: 1.0
| Scalars that match the threshold criteria for ``'in'`` will be replaced with this.
|
| out_value : float, default: 0.0
| Scalars that match the threshold criteria for ``'out'`` will be replaced with this.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset with the specified scalars thresholded.
|
| See Also
| --------
| select_values
| Threshold-like method for keeping some values and replacing others.
| :meth:`~pyvista.DataSetFilters.threshold`
| General threshold method that returns a :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Demonstrate image threshold on an example dataset. First, plot
| the example dataset with the active scalars.
|
| >>> from pyvista import examples
| >>> uni = examples.load_uniform()
| >>> uni.plot()
|
| Now, plot the image threshold with ``threshold=100``. Note how
| values above the threshold are 1 and below are 0.
|
| >>> ithresh = uni.image_threshold(100)
| >>> ithresh.plot()
|
| See :ref:`image_representations_example` for more examples using this filter.
|
| label_connectivity(self, *, scalars: 'str | None' = None, scalar_range: "Literal['auto', 'foreground', 'vtk_default'] | VectorLike[float]" = 'auto', extraction_mode: "Literal['all', 'largest', 'seeded']" = 'all', point_seeds: 'MatrixLike[float] | VectorLike[float] | _vtk.vtkDataSet | None' = None, label_mode: "Literal['size', 'constant', 'seeds']" = 'size', constant_value: 'int | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False) -> 'tuple[ImageData, NDArray[int], NDArray[int]]'
| Find and label connected regions in a :class:`~pyvista.ImageData`.
|
| Only points whose `scalar` value is within the `scalar_range` are considered for
| connectivity. A 4-connectivity is used for 2D images or a 6-connectivity for 3D
| images. This filter operates on point-based data. If cell-based data are provided,
| they are re-meshed to a point-based representation using
| :func:`~pyvista.ImageDataFilters.cells_to_points` and the output is meshed back
| to a cell-based representation with :func:`~pyvista.ImageDataFilters.points_to_cells`,
| effectively filtering based on face connectivity. The connected regions are
| extracted and labelled according to the strategy defined by ``extraction_mode``
| and ``label_mode``, respectively. Unconnected regions are labelled with ``0`` value.
|
| .. versionadded:: 0.45.0
|
| Notes
| -----
| This filter implements :vtk:`vtkImageConnectivityFilter`.
|
| Parameters
| ----------
| scalars : str, optional
| Scalars to use to filter points. If ``None`` is provided, the scalars is
| automatically set, if possible.
|
| scalar_range : str, Literal['auto', 'foreground', 'vtk_default'], VectorLike[float]
| Points whose scalars value is within ``'scalar_range'`` are considered for
| connectivity. The bounds are inclusive.
|
| - ``'auto'``: (default) includes the full data range, similarly to
| :meth:`~pyvista.DataSetFilters.connectivity`.
| - ``'foreground'``: includes the full data range except the smallest value.
| - ``'vtk_default'``: default to [``0.5``, :const:`~vtk.VTK_DOUBLE_MAX`].
| - ``VectorLike[float]``: explicitly set the range.
|
| The bounds are always cast to floats since vtk expects doubles. The scalars
| data are also cast to floats to avoid unexpected behavior arising from implicit
| type conversion. The only exceptions is if both bounds are whole numbers, in
| which case the implicit conversion is safe. It will optimize resources consumption
| if the data are integers.
|
| extraction_mode : Literal['all', 'largest', 'seeded'], default: 'all'
| Determine how the connected regions are extracted. If ``'all'``, all connected
| regions are extracted. If ``'largest'``, only the largest region is extracted.
| If ``'seeded'``, only the regions that include the points defined with
| ``point_seeds`` are extracted.
|
| point_seeds : MatrixLike[float], VectorLike[float], :vtk:`vtkDataSet`, optional
| The point coordinates to use as seeds, specified as a (N, 3) array like or
| as a :vtk:`vtkDataSet`. Has no effect if ``extraction_mode`` is not
| ``'seeded'``.
|
| label_mode : Literal['size', 'constant', 'seeds'], default: 'size'
| Determine how the extracted regions are labelled. If ``'size'``, label regions
| by decreasing size (i.e., count of cells), starting at ``1``. If ``'constant'``,
| label with the provided ``constant_value``. If ``'seeds'``, label according to
| the seed order, starting at ``1``.
|
| constant_value : int, optional
| The constant label value to use. Has no effect if ``label_mode`` is not ``'seeds'``.
|
| inplace : bool, default: False
| If ``True``, perform an inplace labelling of the ImageData. Else, returns a
| new ImageData.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Either the input ImageData or a generated one where connected regions are
| labelled with a ``'RegionId'`` point-based or cell-based data.
|
| NDArray[int]
| The labels of each extracted regions.
|
| NDArray[int]
| The size (i.e., number of cells) of each extracted regions.
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Similar general-purpose filter that performs 1-connectivity.
|
| Examples
| --------
| Prepare a segmented grid.
|
| >>> import pyvista as pv
| >>> segmented_grid = pv.ImageData(dimensions=(4, 3, 3))
| >>> segmented_grid.cell_data['Data'] = [
| ... 0,
| ... 0,
| ... 0,
| ... 1,
| ... 0,
| ... 1,
| ... 1,
| ... 2,
| ... 0,
| ... 0,
| ... 0,
| ... 0,
| ... ]
| >>> segmented_grid.plot(show_edges=True)
|
| Label the connected regions. The cells with a ``0`` value are excluded from the
| connected regions and labelled with ``0``. The remaining cells define 3 different
| regions that are labelled by decreasing size.
|
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range='foreground'
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| Exclude the cell with a ``2`` value.
|
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range=[1, 1]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| Label all connected regions with a constant value.
|
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range='foreground',
| ... label_mode='constant',
| ... constant_value=10,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| Label only the regions that include seed points, by seed order.
|
| >>> points = [(2.0, 1.0, 0.0), (0.0, 0.0, 1.0)]
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range='foreground',
| ... extraction_mode='seeded',
| ... point_seeds=points,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| low_pass(self, x_cutoff, y_cutoff, z_cutoff, order=1, output_scalars_name=None, progress_bar: 'bool' = False)
| Perform a Butterworth low pass filter in the frequency domain.
|
| This filter requires that the :class:`ImageData` have a complex point
| scalars, usually generated after the :class:`ImageData` has been
| converted to the frequency domain by a :func:`ImageDataFilters.fft`
| filter.
|
| A :func:`ImageDataFilters.rfft` filter can be used to convert the
| output back into the spatial domain. This filter attenuates high
| frequency components. Input and output are complex arrays with
| datatype :attr:`numpy.complex128`.
|
| The frequencies of the input assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| x_cutoff : float
| The cutoff frequency for the x-axis.
|
| y_cutoff : float
| The cutoff frequency for the y-axis.
|
| z_cutoff : float
| The cutoff frequency for the z-axis.
|
| order : int, default: 1
| The order of the cutoff curve. Given from the equation
| ``1 + (cutoff/freq(i, j))**(2*order)``.
|
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with the applied low pass filter.
|
| See Also
| --------
| fft : Direct fast Fourier transform.
| rfft : Reverse fast Fourier transform.
| high_pass : High-pass filtering of FFT output.
|
| Examples
| --------
| See :ref:`image_fft_perlin_noise_example` for a full example using this filter.
|
| median_smooth(self, kernel_size=(3, 3, 3), scalars=None, preference='point', progress_bar: 'bool' = False)
| Smooth data using a median filter.
|
| The Median filter that replaces each pixel with the median value from a
| rectangular neighborhood around that pixel. Neighborhoods can be no
| more than 3 dimensional. Setting one axis of the neighborhood
| kernelSize to 1 changes the filter into a 2D median.
|
| See :vtk:`vtkImageMedian3D` for more details.
|
| Parameters
| ----------
| kernel_size : sequence[int], default: (3, 3, 3)
| Size of the kernel in each dimension (units of voxels), for example
| ``(x_size, y_size, z_size)``. Default is a 3D median filter. If you
| want to do a 2D median filter, set the size to 1 in the dimension
| you don't want to filter over.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Uniform grid with smoothed scalars.
|
| Warnings
| --------
| Applying this filter to cell data will send the output to a new point
| array with the same name, overwriting any existing point data array
| with the same name.
|
| Examples
| --------
| First, create sample data to smooth. Here, we use
| :func:`pyvista.perlin_noise() <pyvista.core.utilities.features.perlin_noise>`
| to create meaningful data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 5, 8), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1, 0, 1, 0, 1], dim=(20, 20, 20)
| ... )
| >>> grid.plot(show_scalar_bar=False)
|
| Next, smooth the sample data.
|
| >>> smoothed = grid.median_smooth(kernel_size=(10, 10, 10))
| >>> smoothed.plot(show_scalar_bar=False)
|
| open(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Perform morphological opening on continuous or binary data.
|
| Opening is an :meth:`erosion <erode>` followed by a :meth:`dilation <dilate>`.
| It is used to remove small objects/noise while preserving the shape and size of larger
| objects.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are opened, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary opening or continuous opening is used. Refer to
| :meth:`erode` and/or :meth:`dilate` for details about using this keyword.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been opened.
|
| See Also
| --------
| close, erode, dilate
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| Load a grayscale image :func:`~pyvista.examples.downloads.download_chest()` and show it
| for context.
|
| >>> from pyvista import examples
| >>> im = examples.download_chest()
| >>> clim = im.get_data_range()
| >>> kwargs = dict(
| ... cmap='grey',
| ... clim=clim,
| ... lighting=False,
| ... cpos='xy',
| ... zoom='tight',
| ... show_axes=False,
| ... show_scalar_bar=False,
| ... )
| >>> im.plot(**kwargs)
|
| Use ``open`` to remove small objects in the lungs.
|
| >>> opened = im.open(kernel_size=15)
| >>> opened.plot(**kwargs)
|
| pad_image(self, pad_value: "float | VectorLike[float] | Literal['wrap', 'mirror']" = 0.0, *, pad_size: 'int | VectorLike[int]' = 1, dimensionality: "VectorLike[bool] | Literal[0, 1, 2, 3, '0D', '1D', '2D', '3D', 'preserve']" = 'preserve', scalars: 'str | None' = None, pad_all_scalars: 'bool' = False, progress_bar: 'bool' = False) -> 'ImageData'
| Enlarge an image by padding its boundaries with new points.
|
| .. versionadded:: 0.44.0
|
| Padded points may be mirrored, wrapped, or filled with a constant value. By
| default, all boundaries of the image are padded with a single constant value.
|
| This filter is designed to work with 1D, 2D, or 3D image data and will only pad
| non-singleton dimensions unless otherwise specified.
|
| Parameters
| ----------
| pad_value : float | sequence[float] | 'mirror' | 'wrap', default: 0.0
| Padding value(s) given to new points outside the original image extent.
| Specify:
|
| - a number: New points are filled with the specified constant value.
| - a vector: New points are filled with the specified multi-component vector.
| - ``'wrap'``: New points are filled by wrapping around the padding axis.
| - ``'mirror'``: New points are filled by mirroring the padding axis.
|
| pad_size : int | sequence[int], default: 1
| Number of points to add to the image boundaries. Specify:
|
| - A single value to pad all boundaries equally.
| - Two values, one for each ``(X, Y)`` axis, to apply symmetric padding to
| each axis independently.
| - Three values, one for each ``(X, Y, Z)`` axis, to apply symmetric padding
| to each axis independently.
| - Four values, one for each ``(-X, +X, -Y, +Y)`` boundary, to apply
| padding to each boundary independently.
| - Six values, one for each ``(-X, +X, -Y, +Y, -Z, +Z)`` boundary, to apply
| padding to each boundary independently.
|
| dimensionality : VectorLike[bool], Literal[1, 2, 3, "1D", "2D", "3D", "preserve"]
| Control which dimensions will be padded by the filter.
| ``'preserve'`` is used by default.
|
| - Can be specified as a sequence of 3 boolean to apply padding on a per
| dimension basis.
| - ``1`` or ``'1D'``: apply padding such that the output is a 1D ImageData
| where exactly one dimension is greater than one, e.g. ``(>1, 1, 1)``.
| Only valid for 0D or 1D inputs.
| - ``2`` or ``'2D'``: apply padding such that the output is a 2D ImageData
| where exactly two dimensions are greater than one, e.g. ``(>1, >1, 1)``.
| Only valid for 0D, 1D, or 2D inputs.
| - ``3`` or ``'3D'``: apply padding such that the output is a 3D ImageData,
| where all three dimensions are greater than one, e.g. ``(>1, >1, >1)``.
| Valid for any 0D, 1D, 2D, or 3D inputs.
|
| .. note::
| The ``pad_size`` for singleton dimensions is set to ``0`` by default, even
| if non-zero pad sizes are specified for these axes with this parameter.
| Set ``dimensionality`` to a value different than ``'preserve'`` to
| override this behavior and enable padding any or all dimensions.
|
| .. versionadded:: 0.45.0
|
| scalars : str, optional
| Name of scalars to pad. Defaults to currently active scalars. Unless
| ``pad_all_scalars`` is ``True``, only the specified ``scalars`` are included
| in the output.
|
| pad_all_scalars : bool, default: False
| Pad all point data scalars and include them in the output. This is useful
| for padding images with multiple scalars. If ``False``, only the specified
| ``scalars`` are padded.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Padded image.
|
| See Also
| --------
| crop, resample, contour_labels
|
| Examples
| --------
| Pad a grayscale image with a 100-pixel wide border. The padding is black
| (i.e. has a value of ``0``) by default.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>>
| >>> gray_image = examples.download_moonlanding_image()
| >>> gray_image.dimensions
| (630, 474, 1)
| >>> padded = gray_image.pad_image(pad_size=100)
| >>> padded.dimensions
| (830, 674, 1)
|
| Plot the image. To show grayscale images correctly, we define a custom plotting
| method.
|
| >>> def grayscale_image_plotter(image):
| ... import vtk
| ...
| ... actor = vtk.vtkImageActor()
| ... actor.GetMapper().SetInputData(image)
| ... actor.GetProperty().SetInterpolationTypeToNearest()
| ... pl = pv.Plotter()
| ... pl.add_actor(actor)
| ... pl.view_xy()
| ... pl.camera.tight()
| ... return pl
| >>>
| >>> pl = grayscale_image_plotter(padded)
| >>> pl.show()
|
| Pad only the x-axis with a white border.
|
| >>> padded = gray_image.pad_image(pad_value=255, pad_size=(200, 0))
| >>> pl = grayscale_image_plotter(padded)
| >>> pl.show()
|
| Pad with wrapping.
|
| >>> padded = gray_image.pad_image('wrap', pad_size=100)
| >>> plot = grayscale_image_plotter(padded)
| >>> plot.show()
|
| Pad with mirroring.
|
| >>> padded = gray_image.pad_image('mirror', pad_size=100)
| >>> plot = grayscale_image_plotter(padded)
| >>> plot.show()
|
| Pad a color image using multi-component color vectors. Here, RGBA values are
| used.
|
| >>> color_image = examples.download_beach()
| >>> red = (255, 0, 0) # RGB
| >>> padded = color_image.pad_image(pad_value=red, pad_size=50)
| >>>
| >>> plot_kwargs = dict(cpos='xy', zoom='tight', rgb=True, show_axes=False)
| >>> padded.plot(**plot_kwargs)
|
| Pad each edge of the image separately with a different color.
|
| >>> orange = pv.Color('orange').int_rgb
| >>> purple = pv.Color('purple').int_rgb
| >>> blue = pv.Color('blue').int_rgb
| >>> green = pv.Color('green').int_rgb
| >>>
| >>> padded = color_image.pad_image(orange, pad_size=(25, 0, 0, 0))
| >>> padded = padded.pad_image(purple, pad_size=(0, 25, 0, 0))
| >>> padded = padded.pad_image(blue, pad_size=(0, 0, 25, 0))
| >>> padded = padded.pad_image(green, pad_size=(0, 0, 0, 25))
| >>>
| >>> padded.plot(**plot_kwargs)
|
| points_to_cells(self: 'ImageData', scalars: 'str | None' = None, *, dimensionality: "VectorLike[bool] | Literal[0, 1, 2, 3, '0D', '1D', '2D', '3D', 'preserve']" = 'preserve', copy: 'bool' = True)
| Re-mesh image data from a point-based to a cell-based representation.
|
| This filter changes how image data is represented. Data represented as points
| at the input is re-meshed into an alternative representation as cells at the
| output. Only the :class:`~pyvista.ImageData` container is modified so that
| the number of input points equals the number of output cells. The re-meshing is
| otherwise lossless in the sense that point data at the input is passed through
| unmodified and stored as cell data at the output. Any cell data at the input is
| ignored and is not used by this filter.
|
| To change the image data's representation, the input points are used to
| represent the centers of the output cells. This has the effect of "growing" the
| input image dimensions by one along each axis (i.e. half the cell width on each
| side). For example, an image with 100 points and 99 cells along an axis at the
| input will have 101 points and 100 cells at the output. If the input has 1mm
| spacing, the axis size will also increase from 99mm to 100mm. By default,
| only non-singleton dimensions are increased such that 1D or 2D inputs remain
| 1D or 2D at the output.
|
| Since filters may be inherently cell-based (e.g. some :class:`~pyvista.DataSetFilters`)
| or may operate on point data exclusively (e.g. most :class:`~pyvista.ImageDataFilters`),
| re-meshing enables the same data to be used with either kind of filter while
| ensuring the input data to those filters has the appropriate representation.
| This filter is also useful when plotting image data to achieve a desired visual
| effect, such as plotting images as voxel cells instead of as points.
|
| .. note::
| Only the input's :attr:`~pyvista.ImageData.dimensions`, and
| :attr:`~pyvista.ImageData.origin` are modified by this filter. Other spatial
| properties such as :attr:`~pyvista.ImageData.spacing` and
| :attr:`~pyvista.ImageData.direction_matrix` are not affected.
|
| .. versionadded:: 0.44.0
|
| See Also
| --------
| cells_to_points
| Inverse of this filter to represent cells as points.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample point data as cell data without modifying the container.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample cell data as point data without modifying the container.
|
| Parameters
| ----------
| scalars : str, optional
| Name of point data scalars to pass through to the output as cell data. Use
| this parameter to restrict the output to only include the specified array.
| By default, all point data arrays at the input are passed through as cell
| data at the output.
|
| dimensionality : VectorLike[bool], Literal[0, 1, 2, 3, "0D", "1D", "2D", "3D", "preserve"]
| Control which dimensions will be modified by the filter.
| ``'preserve'`` is used by default.
|
| - Can be specified as a sequence of 3 boolean to allow modification on a per
| dimension basis.
| - ``0`` or ``'0D'``: convenience alias to output a 0D ImageData with
| dimensions ``(1, 1, 1)``. Only valid for 0D inputs.
| - ``1`` or ``'1D'``: convenience alias to output a 1D ImageData where
| exactly one dimension is greater than one, e.g. ``(>1, 1, 1)``. Only valid
| for 0D or 1D inputs.
| - ``2`` or ``'2D'``: convenience alias to output a 2D ImageData where
| exactly two dimensions are greater than one, e.g. ``(>1, >1, 1)``. Only
| valid for 0D, 1D, or 2D inputs.
| - ``3`` or ``'3D'``: convenience alias to output a 3D ImageData, where all
| three dimensions are greater than one, e.g. ``(>1, >1, >1)``. Valid for
| any 0D, 1D, 2D, or 3D inputs.
| - ``'preserve'`` (default): convenience alias to not modify singleton
| dimensions.
|
| copy : bool, default: True
| Copy the input point data before associating it with the output cell data.
| If ``False``, the input and output will both refer to the same data array(s).
|
| Returns
| -------
| pyvista.ImageData
| Image with a cell-based representation.
|
| Examples
| --------
| Load an image with point data.
|
| >>> from pyvista import examples
| >>> image = examples.load_uniform()
|
| Show the current properties and point arrays of the image.
|
| >>> image
| ImageData (...)
| N Cells: 729
| N Points: 1000
| X Bounds: 0.000e+00, 9.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| Dimensions: 10, 10, 10
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 2
|
| >>> image.point_data.keys()
| ['Spatial Point Data']
|
| Re-mesh the points and point data as cells and cell data.
|
| >>> cells_image = image.points_to_cells()
|
| Show the properties and cell arrays of the re-meshed image.
|
| >>> cells_image
| ImageData (...)
| N Cells: 1000
| N Points: 1331
| X Bounds: -5.000e-01, 9.500e+00
| Y Bounds: -5.000e-01, 9.500e+00
| Z Bounds: -5.000e-01, 9.500e+00
| Dimensions: 11, 11, 11
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> cells_image.cell_data.keys()
| ['Spatial Point Data']
|
| Observe that:
|
| - The input point array is now a cell array
| - The output has one less array (the input cell data is ignored)
| - The dimensions have increased by one
| - The bounds have increased by half the spacing
| - The output ``N Cells`` equals the input ``N Points``
|
| Since the input points are 3D (i.e. there are no singleton dimensions), the
| output cells are 3D :attr:`~pyvista.CellType.VOXEL` cells.
|
| >>> cells_image.get_cell(0).type
| <CellType.VOXEL: 11>
|
| If the input points are 2D (i.e. one dimension is singleton), the
| output cells are 2D :attr:`~pyvista.CellType.PIXEL` cells when ``dimensions`` is
| set to ``'preserve'``.
|
| >>> image2D = examples.download_beach()
| >>> image2D.dimensions
| (100, 100, 1)
|
| >>> pixel_cells_image = image2D.points_to_cells(dimensionality='preserve')
| >>> pixel_cells_image.dimensions
| (101, 101, 1)
| >>> pixel_cells_image.get_cell(0).type
| <CellType.PIXEL: 8>
|
| This is equivalent as requesting a 2D output.
|
| >>> pixel_cells_image = image2D.points_to_cells(dimensionality='2D')
| >>> pixel_cells_image.dimensions
| (101, 101, 1)
| >>> pixel_cells_image.get_cell(0).type
| <CellType.PIXEL: 8>
|
| Use ``(True, True, True)`` to re-mesh 2D points as 3D cells.
|
| >>> voxel_cells_image = image2D.points_to_cells(
| ... dimensionality=(True, True, True)
| ... )
| >>> voxel_cells_image.dimensions
| (101, 101, 2)
| >>> voxel_cells_image.get_cell(0).type
| <CellType.VOXEL: 11>
|
| Or request a 3D output.
|
| >>> voxel_cells_image = image2D.points_to_cells(dimensionality='3D')
| >>> voxel_cells_image.dimensions
| (101, 101, 2)
| >>> voxel_cells_image.get_cell(0).type
| <CellType.VOXEL: 11>
|
| See :ref:`image_representations_example` for more examples using this filter.
|
| resample(self: 'ImageData', sample_rate: 'float | VectorLike[float] | None' = None, interpolation: '_InterpolationOptions' = 'nearest', *, border_mode: "Literal['clamp', 'wrap', 'mirror']" = 'clamp', reference_image: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, anti_aliasing: 'bool' = False, extend_border: 'bool | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Resample the image to modify its dimensions and spacing.
|
| The resampling can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_image``.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``sample_rate`` explicitly.
|
| Use ``reference_image`` for full control of the resampled geometry. For
| all other options, the geometry is implicitly defined such that the resampled
| image fits the bounds of the input.
|
| This filter may be used to resample either point or cell data. For point data,
| this filter assumes the data is from discrete samples in space which represent
| pixels or voxels; the resampled bounds are therefore extended by 1/2 voxel
| spacing by default though this may be disabled.
|
| .. note::
|
| Singleton dimensions are not resampled by this filter, e.g. 2D images
| will remain 2D.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| sample_rate : float | VectorLike[float], optional
| Sampling rate(s) to use. Can be a single value or vector of three values
| for each axis. Values greater than ``1.0`` will up-sample the axis and
| values less than ``1.0`` will down-sample it. Values must be greater than ``0``.
|
| interpolation : 'nearest', 'linear', 'cubic', 'lanczos', 'hamming', 'blackman', 'bspline'
| Interpolation mode to use.
|
| - ``'nearest'`` (default) duplicates (if upsampling) or removes (if downsampling)
| values but does not modify them.
| - ``'linear'`` and ``'cubic'`` use linear and cubic interpolation, respectively.
| - ``'lanczos'``, ``'hamming'``, and ``'blackman'`` use a windowed sinc filter
| and may be used to preserve sharp details and/or reduce image artifacts.
| - ``'bspline'`` uses an n-degree basis spline to smoothly interpolate across points.
| The default degree is ``3``, but can range from ``0`` to ``9``. Append the desired
| degree to the string to set it, e.g. ``'bspline5'`` for a 5th-degree B-spline.
|
| .. versionadded:: 0.47
| Added ``'bspline'`` interpolation.
|
| .. note::
|
| - use ``'nearest'`` for pixel art or categorical data such as segmentation masks
| - use ``'linear'`` for speed-critical tasks
| - use ``'cubic'`` for upscaling or general-purpose resampling
| - use ``'lanczos'`` for high-detail downsampling (at the cost of some ringing)
| - use ``'blackman'`` for minimizing ringing artifacts (at the cost of some detail)
| - use ``'hamming'`` for a balance between detail-preservation and reducing ringing
|
| border_mode : 'clamp' | 'wrap' | 'mirror', default: 'clamp'
| Controls the interpolation at the image's borders.
|
| - ``'clamp'`` - values outside the image are clamped to the nearest edge.
| - ``'wrap'`` - values outside the image are wrapped periodically along the axis.
| - ``'mirror'`` - values outside the image are mirrored at the boundary.
|
| .. versionadded:: 0.47
|
| reference_image : ImageData, optional
| Reference image to use. If specified, the input is resampled
| to match the geometry of the reference. The :attr:`~pyvista.ImageData.dimensions`,
| :attr:`~pyvista.ImageData.spacing`, :attr:`~pyvista.ImageData.origin`,
| :attr:`~pyvista.ImageData.offset`, and :attr:`~pyvista.ImageData.direction_matrix`
| of the resampled image will all match the reference image.
|
| dimensions : VectorLike[int], optional
| Set the output :attr:`~pyvista.ImageData.dimensions` of the resampled image.
|
| .. note::
|
| Dimensions is the number of `points` along each axis. If resampling
| `cell` data, each dimension should be one more than the number of
| desired output cells (since there are ``N`` cells and ``N+1`` points
| along each axis). See examples.
|
| anti_aliasing : bool, default: False
| Enable antialiasing. This will blur the image as part of the resampling
| to reduce image artifacts when down-sampling. Has no effect when up-sampling.
|
| extend_border : bool, optional
| Extend the apparent input border by approximately half the
| :attr:`~pyvista.ImageData.spacing`. If enabled, the bounds of the
| resampled points will be larger than the input image bounds.
| Enabling this option also has the effect that the re-sampled spacing
| will directly correlate with the resampled dimensions, e.g. if
| the dimensions are doubled the spacing will be halved. See examples.
|
| This option is enabled by default when resampling point data. Has no effect
| when resampling cell data or when a ``reference_image`` is provided.
|
| scalars : str, optional
| Name of scalars to resample. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When scalars is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| inplace : bool, default: False
| If ``True``, resample the image inplace. By default, a new
| :class:`~pyvista.ImageData` instance is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Resampled image.
|
| See Also
| --------
| crop
| Crop image to remove points at the image's boundaries.
|
| :meth:`~pyvista.DataObjectFilters.sample`
| Resample array data from one mesh onto another.
|
| :meth:`~pyvista.DataSetFilters.interpolate`
| Interpolate values from one mesh onto another.
|
| :ref:`image_representations_example`
| Compare images represented as points vs. cells.
|
| Examples
| --------
| Create a small 2D grayscale image with dimensions ``3 x 2`` for demonstration.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> from pyvista import examples
| >>> image = pv.ImageData(dimensions=(3, 2, 1))
| >>> image.point_data['data'] = np.linspace(0, 255, 6, dtype=np.uint8)
|
| Define a custom plotter to show the image. Although the image data is defined
| as point data, we use :meth:`points_to_cells` to display the image as
| :attr:`~pyvista.CellType.PIXEL` (or :attr:`~pyvista.CellType.VOXEL`) cells
| instead. Grayscale coloring is used and the camera is adjusted to fit the image.
|
| >>> def image_plotter(image: pv.ImageData, clim=(0, 255)) -> pv.Plotter:
| ... pl = pv.Plotter()
| ... image = image.points_to_cells()
| ... pl.add_mesh(
| ... image,
| ... lighting=False,
| ... show_edges=True,
| ... cmap='grey',
| ... clim=clim,
| ... show_scalar_bar=False,
| ... line_width=3,
| ... )
| ... pl.view_xy()
| ... pl.camera.tight()
| ... pl.enable_anti_aliasing()
| ... return pl
|
| Show the image.
|
| >>> plot = image_plotter(image)
| >>> plot.show()
|
| Use ``sample_rate`` to up-sample the image. ``'nearest'`` interpolation is
| used by default.
|
| >>> upsampled = image.resample(sample_rate=2.0)
| >>> plot = image_plotter(upsampled)
| >>> plot.show()
|
| Use ``'linear'`` interpolation. Note that the argument names ``sample_rate``
| and ``interpolation`` may be omitted.
|
| >>> upsampled = image.resample(2.0, 'linear')
| >>> plot = image_plotter(upsampled)
| >>> plot.show()
|
| Use ``'cubic'`` interpolation. Here we also specify the output
| ``dimensions`` explicitly instead of using ``sample_rate``.
|
| >>> upsampled = image.resample(dimensions=(6, 4, 1), interpolation='cubic')
| >>> plot = image_plotter(upsampled)
| >>> plot.show()
|
| Compare the relative physical size of the image before and after resampling.
|
| >>> image
| ImageData (...)
| N Cells: 2
| N Points: 6
| X Bounds: 0.000e+00, 2.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 3, 2, 1
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> upsampled
| ImageData (...)
| N Cells: 15
| N Points: 24
| X Bounds: -2.500e-01, 2.250e+00
| Y Bounds: -2.500e-01, 1.250e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 6, 4, 1
| Spacing: 5.000e-01, 5.000e-01, 1.000e+00
| N Arrays: 1
|
| Note that the upsampled :attr:`~pyvista.ImageData.dimensions` are doubled and
| the :attr:`~pyvista.ImageData.spacing` is halved (as expected). Also note,
| however, that the physical bounds of the input differ from the output.
| The upsampled :attr:`~pyvista.ImageData.origin` also differs:
|
| >>> image.origin
| (0.0, 0.0, 0.0)
| >>> upsampled.origin
| (-0.25, -0.25, 0.0)
|
| This is because the resampling is done with ``extend_border`` enabled by default
| which adds a half cell-width border to the image and adjusts the origin and
| spacing such that the bounds match when the image is represented as cells.
|
| Apply :meth:`points_to_cells` to the input and resampled images and show that
| the bounds match.
|
| >>> image_as_cells = image.points_to_cells()
| >>> image_as_cells.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = 0.0,
| z_max = 0.0)
|
| >>> upsampled_as_cells = upsampled.points_to_cells()
| >>> upsampled_as_cells.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = 0.0,
| z_max = 0.0)
|
| Plot the two images together as wireframe to visualize them. The original is in
| red, and the resampled image is in black.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... image_as_cells, style='wireframe', color='red', line_width=10
| ... )
| >>> _ = pl.add_mesh(
| ... upsampled_as_cells, style='wireframe', color='black', line_width=2
| ... )
| >>> pl.view_xy()
| >>> pl.camera.tight()
| >>> pl.show()
|
| Disable ``extend_border`` to force the input and output bounds of the points
| to be the same instead.
|
| >>> upsampled = image.resample(sample_rate=2, extend_border=False)
|
| Compare the two images again.
|
| >>> image
| ImageData (...)
| N Cells: 2
| N Points: 6
| X Bounds: 0.000e+00, 2.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 3, 2, 1
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> upsampled
| ImageData (...)
| N Cells: 15
| N Points: 24
| X Bounds: 0.000e+00, 2.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 6, 4, 1
| Spacing: 4.000e-01, 3.333e-01, 1.000e+00
| N Arrays: 1
|
| This time the input and output bounds match without any further processing.
| Like before, the dimensions have doubled; unlike before, however, the spacing is
| not halved, but is instead smaller than half which is necessary to ensure the
| bounds remain the same. Also unlike before, the origin is unaffected:
|
| >>> image.origin
| (0.0, 0.0, 0.0)
| >>> upsampled.origin
| (0.0, 0.0, 0.0)
|
| All the above examples are with 2D images with point data. However, the filter
| also works with 3D volumes and will also work with cell data.
|
| Convert the 2D image with point data into a 3D volume with cell data and plot
| it for context.
|
| >>> volume = image.points_to_cells(dimensionality='3D')
| >>> volume.plot(show_edges=True, cmap='grey')
|
| Up-sample the volume. Set the sampling rate for each axis separately.
|
| >>> resampled = volume.resample(sample_rate=(3.0, 2.0, 1.0))
| >>> resampled.plot(show_edges=True, cmap='grey')
|
| Alternatively, we could have set the dimensions explicitly. Since we want
| ``9 x 4 x 1`` cells along the x-y-z axes (respectively), we set the dimensions
| to ``(10, 5, 2)``, i.e. one more than the desired number of cells.
|
| >>> resampled = volume.resample(dimensions=(10, 5, 2))
| >>> resampled.plot(show_edges=True, cmap='grey')
|
| Compare the bounds before and after resampling. Unlike with point data, the
| bounds are not (and cannot be) extended.
|
| >>> volume.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = -0.5,
| z_max = 0.5)
| >>> resampled.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = -0.5,
| z_max = 0.5)
|
| Use a reference image to control the resampling instead. Here we load two
| images with different dimensions:
| :func:`~pyvista.examples.downloads.download_bird` and
| :func:`~pyvista.examples.downloads.download_gourds`.
|
| >>> bird = examples.download_bird()
| >>> bird.dimensions
| (458, 342, 1)
|
| >>> gourds = examples.download_gourds()
| >>> gourds.dimensions
| (640, 480, 1)
|
| Use ``reference_image`` to resample the bird to match the gourds geometry or
| vice-versa.
|
| >>> bird_resampled = bird.resample(reference_image=gourds)
| >>> bird_resampled.dimensions
| (640, 480, 1)
|
| >>> gourds_resampled = gourds.resample(reference_image=bird)
| >>> gourds_resampled.dimensions
| (458, 342, 1)
|
| Downsample the gourds image to 1/10th its original resolution using ``'lanczos'``
| interpolation.
|
| >>> downsampled = gourds.resample(1 / 8, 'lanczos')
| >>> downsampled.dimensions
| (80, 60, 1)
|
| Compare the downsampled image to the original and zoom in to show detail.
|
| >>> def compare_images_plotter(image1, image2):
| ... pl = pv.Plotter(shape=(1, 2))
| ... _ = pl.add_mesh(image1, rgba=True, show_edges=False, lighting=False)
| ... pl.subplot(0, 1)
| ... _ = pl.add_mesh(image2, rgba=True, show_edges=False, lighting=False)
| ... pl.link_views()
| ... pl.view_xy()
| ... pl.camera.zoom(3.0)
| ... return pl
|
| >>> pl = compare_images_plotter(gourds, downsampled)
| >>> pl.show()
|
| Note that downsampling can create image artifacts caused by aliasing. Enable
| anti-aliasing to smooth the image before resampling.
|
| >>> downsampled2 = gourds.resample(1 / 8, 'lanczos', anti_aliasing=True)
|
| Compare down-sampling with aliasing (left) to without aliasing (right).
|
| >>> pl = compare_images_plotter(downsampled, downsampled2)
| >>> pl.show()
|
| Load an MRI of a knee and downsample it.
|
| >>> knee = pv.examples.download_knee().resample(
| ... 0.1, 'linear', anti_aliasing=True
| ... )
|
| Crop and plot it.
|
| >>> knee = knee.crop(normalized_bounds=[0.2, 0.8, 0.2, 0.8, 0.0, 1.0])
| >>> vmin = knee.active_scalars.min()
| >>> vmax = knee.active_scalars.max()
| >>> pl = image_plotter(knee, clim=[vmin, vmax])
| >>> pl.show()
|
| Upsample it with B-spline interpolation. The interpolation is very smooth.
|
| >>> upsampled = knee.resample(2.0, 'bspline', border_mode='clamp')
| >>> pl = image_plotter(upsampled, clim=[vmin, vmax])
| >>> pl.show()
|
| Use the ``'wrap'`` border mode. Note how points at the border are brighter than previously,
| since the bright pixels from the opposite edge are now included in the interpolation.
|
| >>> upsampled = knee.resample(2.0, 'bspline', border_mode='wrap')
| >>> pl = image_plotter(upsampled, clim=[vmin, vmax])
| >>> pl.show()
|
| Compare B-spline interpolation to ``'hamming'``.
|
| >>> upsampled = knee.resample(2.0, 'hamming')
| >>> pl = image_plotter(upsampled, clim=[vmin, vmax])
| >>> pl.show()
|
| rfft(self, output_scalars_name=None, progress_bar: 'bool' = False)
| Apply a reverse fast Fourier transform (RFFT) to the active scalars.
|
| The input can be real or complex data, but the output is always
| :attr:`numpy.complex128`. The filter is fastest for images that have power
| of two sizes.
|
| The filter uses a butterfly diagram for each prime factor of the
| dimension. This makes images with prime number dimensions (i.e. 17x17)
| much slower to compute. FFTs of multidimensional meshes (i.e volumes)
| are decomposed so that each axis executes serially.
|
| The frequencies of the input assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with the applied reverse FFT.
|
| See Also
| --------
| fft : The direct transform.
| low_pass : Low-pass filtering of FFT output.
| high_pass : High-pass filtering of FFT output.
|
| Examples
| --------
| Apply reverse FFT to an example image.
|
| >>> from pyvista import examples
| >>> image = examples.download_moonlanding_image()
| >>> fft_image = image.fft()
| >>> image_again = fft_image.rfft()
| >>> image_again.point_data # doctest:+SKIP
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : PNGImage
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| PNGImage complex128 (298620,) SCALARS
|
| See :ref:`image_fft_example` for a full example using this filter.
|
| select_values(self: 'ImageData', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, fill_value: 'float | VectorLike[float]' = 0, replacement_value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, split: 'bool' = False)
| Select values of interest and fill the rest with a constant.
|
| Point or cell data may be selected with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to select a single label or groups
| of labels from categorical data, or to select multiple regions from continuous
| data. Selected values may optionally be split into separate meshes.
|
| The selected values are stored in an array with the same name as the input.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to select. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When selecting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to select. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| selection. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to select values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to select values less than or equal to zero.
|
| fill_value : float | VectorLike[float] | None, default: 0
| Value used to fill the image. Can be a single value or a multi-component
| vector. Non-selected parts of the image will have this value. Set this to
| ``None`` to keep the input array's original values for non-selected regions.
|
| replacement_value : float | VectorLike[float], optional
| Replacement value for the output array. Can be a single value or a
| multi-component vector. If provided, selected values will be replaced with
| the given value. If no value is given, the selected values are retained and
| returned as-is. Setting this value is useful for generating a binarized
| output array.
|
| scalars : str, optional
| Name of scalars to select from. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the selection. If ``True`` values are selected which do *not* have
| the specified values.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| selected independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain meshes with only the ``fill_value`` if no
| values meet the selection criteria.
|
| See Also
| --------
| image_threshold
| Similar filter for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Similar threshold-like filter for extracting values from any dataset.
| :meth:`~pyvista.DataSetFilters.split_values`
| Split a mesh by value into separate meshes.
| :meth:`~pyvista.DataSetFilters.threshold`
| Generalized thresholding filter which returns a :class:`~pyvista.UnstructuredGrid`.
|
| Returns
| -------
| output : pyvista.ImageData | pyvista.MultiBlock
| Image with selected values or a composite of meshes with selected
| values, depending on ``split``.
|
| Examples
| --------
| Load a CT image. Here we load
| :func:`~pyvista.examples.downloads.download_whole_body_ct_male`.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.download_whole_body_ct_male()
| >>> ct_image = dataset['ct']
|
| Show the initial data range.
|
| >>> ct_image.get_data_range()
| (np.int16(-1348), np.int16(3409))
|
| Select intensity values above ``150`` to select the bones.
|
| >>> bone_range = [150, float('inf')]
| >>> fill_value = -1000 # fill with intensity values corresponding to air
| >>> bone_image = ct_image.select_values(
| ... ranges=bone_range, fill_value=fill_value
| ... )
|
| Show the new data range.
|
| >>> bone_image.get_data_range()
| (np.int16(-1000), np.int16(3409))
|
| Plot the selected values. Use ``'foreground'`` opacity to make the fill value
| transparent and the selected values opaque.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_volume(
| ... bone_image,
| ... opacity='foreground',
| ... cmap='bone',
| ... )
| >>> pl.view_zx()
| >>> pl.camera.up = (0, 0, 1)
| >>> pl.show()
|
| Use ``'replacement_value'`` to binarize the selected values instead. The fill
| value, or background, is ``0`` by default.
|
| >>> bone_mask = ct_image.select_values(ranges=bone_range, replacement_value=1)
| >>> bone_mask.get_data_range()
| (np.int16(0), np.int16(1))
|
| Generate a surface contour of the mask and plot it.
|
| >>> surf = bone_mask.contour_labels()
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(surf, color=True)
| >>> pl.view_zx()
| >>> pl.camera.up = (0, 0, 1)
| >>> pl.show()
|
| Load a color image. Here we load :func:`~pyvista.examples.downloads.download_beach`.
|
| >>> image = examples.download_beach()
| >>> plot_kwargs = dict(
| ... cpos='xy', rgb=True, lighting=False, zoom='tight', show_axes=False
| ... )
| >>> image.plot(**plot_kwargs)
|
| Select components from the image which have a strong red component.
| Use ``replacement_value`` to replace these pixels with a pure red color
| and ``fill_value`` to fill the rest of the image with white pixels.
|
| >>> white = [255, 255, 255]
| >>> red = [255, 0, 0]
| >>> red_range = [200, 255]
| >>> red_component = 0
| >>> selected = image.select_values(
| ... ranges=red_range,
| ... component_mode=red_component,
| ... replacement_value=red,
| ... fill_value=white,
| ... )
|
| >>> selected.plot(**plot_kwargs)
|
| slice_index(self: 'ImageData', i: 'int | VectorLike[int] | slice | None' = None, j: 'int | VectorLike[int] | slice | None' = None, k: 'int | VectorLike[int] | slice | None' = None, *, index_mode: "Literal['extent', 'dimensions']" = 'dimensions', strict_index: 'bool' = False, rebase_coordinates: 'bool' = False, progress_bar: 'bool' = False) -> 'ImageData'
| Extract a subset using IJK indices.
|
| This filter enables slicing :class:`~pyvista.ImageData` with Python-style indexing using
| IJK coordinates. It can be used to extract a single slice, multiple contiguous slices, or
| a volume of interest. Unlike other slicing filters, this filter returns
| :class:`~pyvista.ImageData`.
|
| .. note::
| Slicing by index is also possible using the "get index" operator ``[]``. See examples.
|
| .. versionadded::0.46
|
| Parameters
| ----------
| i, j, k : int | VectorLike[int] | slice, optional
| Indices to slice along the I, J, and K coordinate axes, respectively. Specify an
| integer for a single index, or two integers ``[start, stop)`` for a range of indices.
|
| .. note::
|
| Like regular Python slicing:
|
| - Half-open intervals are used, i.e. the ``start`` index is included in the range
| but the ``stop`` index is not.
| - Negative indexing is supported.
| - An ``IndexError`` is raised when a single integer is specified as the index and
| the index is out-of-bounds.
| - An ``IndexError`` is `not` raised when a range is specified as the index and
| the index is out-of-bounds. This default can be overridden by setting
| ``strict_index=True``.
| - A copy of the data is returned (modifying the sliced output does `not` affect
| the input data).
|
| index_mode : 'extent' | 'dimensions', default: 'dimensions'
| Mode to use when determining the range of values to index from.
|
| - Use ``'dimensions'`` to index values in the range ``[0, dimensions - 1]``.
| - Use ``'extent'`` to index values based on the :class:`~pyvista.ImageData.extent`,
| i.e. ``[offset, offset + dimensions - 1]``.
|
| The main difference between these modes is the inclusion or exclusion of the
| :attr:`~pyvista.ImageData.offset`. ``dimensions`` is more pythonic and is how the
| object's data arrays themselves would be indexed, whereas ``'extent'`` respects VTK's
| definition of ``extent`` and considers the object's geometry.
|
| strict_index : bool, default: False
| Raise an ``IndexError`` if `any` of the indices are out of range. By default, an
| ``IndexError`` is only raised if a single integer index is out of range, but not when
| a range of indices are specified; set this to ``True`` to raise in error in both cases.
|
| rebase_coordinates : bool, default: False
| Rebase the coordinate reference of the extracted subset:
|
| - the :attr:`~pyvista.ImageData.origin` is set to the minimum bounds of the subset
| - the :attr:`~pyvista.ImageData.offset` is reset to ``(0, 0, 0)``
|
| The rebasing effectively applies a positive translation in world (XYZ) coordinates and
| a similar (i.e. inverse) negative translation in voxel (IJK) coordinates. As a result,
| the :attr:`~pyvista.DataSet.bounds` of the output are unchanged, but the coordinate
| reference frame is modified.
|
| Set this to ``False`` to leave the origin unmodified and keep the offset specified by
| the indexing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Sliced mesh.
|
| See Also
| --------
| crop
| extract_subset
| :meth:`~pyvista.DataObjectFilters.slice`
| :meth:`~pyvista.DataObjectFilters.slice_implicit`
| :meth:`~pyvista.DataObjectFilters.slice_orthogonal`
| :meth:`~pyvista.DataObjectFilters.slice_along_axis`
| :meth:`~pyvista.DataObjectFilters.slice_along_line`
|
| Examples
| --------
| Create a :class:`~pyvista.ImageData` mesh and give it some point data.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(10, 10, 10))
| >>> mesh['data'] = range(mesh.n_points)
|
| Extract a single slice along the k-axis.
|
| >>> sliced = mesh.slice_index(k=5)
| >>> sliced.dimensions
| (10, 10, 1)
|
| Equivalently:
|
| >>> sliced2 = mesh[:, :, 5]
| >>> sliced == sliced2
| True
|
| Extract a volume of interest.
|
| >>> sliced = mesh.slice_index(i=[1, 3], j=[2, 5], k=[5, 10])
| >>> sliced.dimensions
| (2, 3, 5)
|
| Equivalently:
|
| >>> sliced2 = mesh[1:3, 2:5, 5:10]
| >>> sliced == sliced2
| True
|
| Use ``None`` to implicitly define the start and/or stop indices.
|
| >>> sliced = mesh.slice_index(i=[None, 3], j=[2, None], k=None)
| >>> sliced.dimensions
| (3, 8, 10)
|
| Equivalently:
|
| >>> sliced2 = mesh[:3, 2:, :]
| >>> sliced == sliced2
| True
|
| See :ref:`slice_example` for more examples using this filter.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
class PolyDataFilters(pyvista.core.filters.data_set.DataSetFilters)
| PolyDataFilters(*args, **kwargs)
|
| An internal class to manage filters/algorithms for polydata datasets.
|
| Method resolution order:
| PolyDataFilters
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| builtins.object
|
| Methods defined here:
|
| __add__(self: 'PolyData', dataset)
| Merge these two meshes.
|
| __iadd__(self: 'PolyData', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``dataset`` is also a :class:`PolyData`.
| Otherwise we have to return a :class:`pyvista.UnstructuredGrid`,
| so the in-place merge attempt will raise.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| append_polydata(self, *meshes, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Append one or more PolyData into this one.
|
| Under the hood, the VTK :vtk:`vtkAppendPolyData`
| filter is used to perform the append operation.
|
| .. versionadded:: 0.40.0
|
| .. note::
| As stated in the VTK documentation of :vtk:`vtkAppendPolyData`,
| point and cell data are added to the output PolyData **only** if they
| are present across **all** input PolyData.
|
| .. seealso::
| :func:`pyvista.PolyDataFilters.merge`
|
| Parameters
| ----------
| *meshes : list[pyvista.PolyData]
| The PolyData(s) to append with the current one.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Appended PolyData(s).
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sp0 = pv.Sphere()
| >>> sp1 = sp0.translate((1, 0, 0))
| >>> appended = sp0.append_polydata(sp1)
| >>> appended.plot()
|
| Append more than one PolyData.
|
| >>> sp2 = sp0.translate((-1, 0, 0))
| >>> appended = sp0.append_polydata(sp1, sp2)
| >>> appended.plot()
|
| boolean_difference(self, other_mesh, tolerance=1e-05, progress_bar: 'bool' = False)
| Perform a boolean difference operation between two meshes.
|
| Essentially, boolean union, difference, and intersection are
| all the same operation. Just different parts of the objects
| are kept at the end.
|
| The difference of two manifold meshes ``A`` and ``B`` is the
| volume of the mesh in ``A`` not belonging to ``B``.
|
| .. note::
| If your boolean operations don't react the way you think they
| should (i.e. the wrong parts disappear), one of your meshes
| probably has its normals pointing inward. Use
| :func:`PolyDataFilters.plot_normals` to visualize the
| normals.
|
| .. note::
| Both meshes must be composed of all triangles. Check with
| :attr:`PolyData.is_all_triangles` and convert with
| :func:`PolyDataFilters.triangulate`.
|
| .. versionchanged:: 0.32.0
| Behavior changed to match default VTK behavior.
|
| Parameters
| ----------
| other_mesh : pyvista.PolyData
| Mesh operating on the source mesh.
|
| tolerance : float, default: 1e-5
| Tolerance used to determine when a point's absolute
| distance is considered to be zero.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The result of the boolean operation.
|
| Examples
| --------
| Demonstrate a boolean difference with two spheres. Note how
| the final mesh only includes ``sphere_a``.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> result = sphere_a - sphere_b
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere_a, color='r', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(sphere_b, color='b', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(result, color='lightblue')
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| boolean_intersection(self, other_mesh, tolerance=1e-05, progress_bar: 'bool' = False)
| Perform a boolean intersection operation on two meshes.
|
| Essentially, boolean union, difference, and intersection are
| all the same operation. Just different parts of the objects
| are kept at the end.
|
| The intersection of two manifold meshes ``A`` and ``B`` is the mesh
| which is the volume of ``A`` that is also in ``B``.
|
| .. note::
| If your boolean operations don't react the way you think they
| should (i.e. the wrong parts disappear), one of your meshes
| probably has its normals pointing inward. Use
| :func:`PolyDataFilters.plot_normals` to visualize the
| normals.
|
| .. note::
| This method returns the "volume" intersection between two
| meshes whereas the :func:`PolyDataFilters.intersection`
| filter returns the surface intersection between two meshes
| (which often resolves as a line).
|
|
| .. note::
| Both meshes must be composed of all triangles. Check with
| :attr:`PolyData.is_all_triangles` and convert with
| :func:`PolyDataFilters.triangulate`.
|
| .. versionadded:: 0.32.0
|
| .. versionchanged:: 0.45.0
| Define ``&`` operator to perform boolean intersection.
|
| Parameters
| ----------
| other_mesh : pyvista.PolyData
| Mesh operating on the source mesh.
|
| tolerance : float, default: 1e-5
| Tolerance used to determine when a point's absolute
| distance is considered to be zero.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The result of the boolean operation.
|
| Examples
| --------
| Demonstrate a boolean intersection with two spheres. Note how
| the final mesh only includes the intersection of the two.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> result = sphere_a & sphere_b
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere_a, color='r', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(sphere_b, color='b', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(result, color='lightblue')
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| boolean_union(self, other_mesh, tolerance=1e-05, progress_bar: 'bool' = False)
| Perform a boolean union operation on two meshes.
|
| Essentially, boolean union, difference, and intersection are
| all the same operation. Just different parts of the objects
| are kept at the end.
|
| The union of two manifold meshes ``A`` and ``B`` is the mesh
| which is in ``A``, in ``B``, or in both ``A`` and ``B``.
|
| .. note::
| If your boolean operations don't react the way you think they
| should (i.e. the wrong parts disappear), one of your meshes
| probably has its normals pointing inward. Use
| :func:`PolyDataFilters.plot_normals` to visualize the
| normals.
|
| .. note::
| The behavior of this filter varies from the
| :func:`PolyDataFilters.merge` filter. This filter attempts
| to create a manifold mesh and will not include internal
| surfaces when two meshes overlap.
|
| .. note::
| Both meshes must be composed of all triangles. Check with
| :attr:`PolyData.is_all_triangles` and convert with
| :func:`PolyDataFilters.triangulate`.
|
| .. versionchanged:: 0.32.0
| Behavior changed to match default VTK behavior.
|
| .. versionchanged:: 0.45.0
| Define ``|`` operator to perform boolean union.
|
| Parameters
| ----------
| other_mesh : pyvista.PolyData
| Mesh operating on the source mesh.
|
| tolerance : float, tolerance: 1e-5
| Tolerance used to determine when a point's absolute
| distance is considered to be zero.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The result of the boolean operation.
|
| Examples
| --------
| Demonstrate a boolean union with two spheres. Note how the
| final mesh includes both spheres.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> result = sphere_a | sphere_b
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere_a, color='r', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(sphere_b, color='b', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(result, color='lightblue')
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| clean(self, point_merging: 'bool' = True, tolerance=None, lines_to_points: 'bool' = True, polys_to_lines: 'bool' = True, strips_to_polys: 'bool' = True, inplace: 'bool' = False, absolute: 'bool' = True, progress_bar: 'bool' = False, **kwargs)
| Clean the mesh.
|
| This merges duplicate points, removes unused points, and/or
| removes degenerate cells.
|
| Parameters
| ----------
| point_merging : bool, optional
| Enables point merging. ``True`` by default.
|
| tolerance : float, optional
| Set merging tolerance. When enabled merging is set to
| absolute distance. If ``absolute`` is ``False``, then the
| merging tolerance is a fraction of the bounding box
| length. The alias ``merge_tol`` is also excepted.
|
| lines_to_points : bool, optional
| Enable or disable the conversion of degenerate lines to
| points. Enabled by default.
|
| polys_to_lines : bool, optional
| Enable or disable the conversion of degenerate polys to
| lines. Enabled by default.
|
| strips_to_polys : bool, optional
| Enable or disable the conversion of degenerate strips to
| polys.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| absolute : bool, optional
| Control if ``tolerance`` is an absolute distance or a
| fraction.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts for ``merge_tol`` to replace the ``tolerance``
| keyword argument. This may be deprecated in future.
|
| Returns
| -------
| pyvista.PolyData
| Cleaned mesh.
|
| See Also
| --------
| remove_unused_points
| Strictly remove unused points `without` merging points.
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Create a mesh with a degenerate face and then clean it,
| removing the degenerate face
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array([[0, 0, 0], [0, 1, 0], [1, 0, 0]], dtype=np.float32)
| >>> faces = np.array([3, 0, 1, 2, 3, 0, 2, 2])
| >>> mesh = pv.PolyData(points, faces)
| >>> mout = mesh.clean()
| >>> mout.faces # doctest:+SKIP
| array([3, 0, 1, 2])
|
| clip_closed_surface(self: 'PolyData', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, tolerance=1e-06, inplace: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a closed polydata surface with a plane.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| This currently only supports one plane but could be
| implemented to handle a plane collection.
|
| It will produce a new closed surface by creating new polygonal
| faces where the input data was clipped.
|
| Non-manifold surfaces should not be used as input for this
| filter. The input surface should have no open edges, and must
| not have any edges that are shared by more than two faces. In
| addition, the input surface should not self-intersect, meaning
| that the faces of the surface should only touch at their
| edges.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| tolerance : float, optional
| The tolerance for creating new points while clipping. If
| the tolerance is too small, then degenerate triangles
| might be produced.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| The clipped mesh.
|
| Examples
| --------
| Clip a sphere in the X direction centered at the origin. This
| will leave behind half a sphere in the positive X direction.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> clipped_mesh = sphere.clip_closed_surface('-z')
| >>> clipped_mesh.plot(show_edges=True, line_width=3)
|
| Clip the sphere at the XY plane and leave behind half the
| sphere in the positive Z direction. Shift the clip upwards to
| leave a smaller mesh behind.
|
| >>> clipped_mesh = sphere.clip_closed_surface('z', origin=[0, 0, 0.3])
| >>> clipped_mesh.plot(show_edges=True, line_width=3)
|
| See :ref:`clip_closed_surface_example` for more examples using this filter.
|
| collision(self, other_mesh, contact_mode=0, box_tolerance=0.001, cell_tolerance=0.0, n_cells_per_node=2, generate_scalars: 'bool' = False, progress_bar: 'bool' = False)
| Perform collision determination between two polyhedral surfaces.
|
| If ``collision_mode`` is set to all contacts, the output will
| be lines of contact. If ``collision_mode`` is first contact or half
| contacts then the Contacts output will be vertices.
|
| .. warning::
| Currently only triangles are processed. Use
| :func:`PolyDataFilters.triangulate` to convert any strips
| or polygons to triangles. Otherwise, the mesh will be
| converted for you within this method.
|
| Parameters
| ----------
| other_mesh : pyvista.DataSet
| Other mesh to test collision with. If the other mesh is
| not a surface, its external surface will be extracted and
| triangulated.
|
| contact_mode : int, default: 0
| Contact mode. One of the following:
|
| * 0 - All contacts. Find all the contacting cell pairs
| with two points per collision
| * 1 - First contact. Quickly find the first contact point.
| * 2 - Half contacts. Find all the contacting cell pairs
| with one point per collision.
|
| box_tolerance : float, default: 0.001
| Oriented bounding box (OBB) tree tolerance in world coordinates.
|
| cell_tolerance : float, default: 0.0
| Cell tolerance (squared value).
|
| n_cells_per_node : int, default: 2
| Number of cells in each OBB.
|
| generate_scalars : bool, default: False
| Flag to visualize the contact cells. If ``True``, the
| contacting cells will be colored from red through blue,
| with collisions first determined colored red. This array
| is stored as ``"collision_rgba"``.
|
| .. note::
| This will remove any other cell arrays in the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing collisions in the ``field_data``
| attribute named ``"ContactCells"``. Array only exists
| when there are collisions.
|
| int
| Number of collisions.
|
| Notes
| -----
| Due to the nature of the :vtk:`vtkCollisionDetectionFilter`,
| repeated uses of this method will be slower that using the
| :vtk:`vtkCollisionDetectionFilter` directly. The first
| update of the filter creates two instances of :vtk:`vtkOBBTree`,
| which can be subsequently updated by modifying the transform or
| matrix of the input meshes.
|
| This method assumes no transform and is easier to use for
| single collision tests, but it is recommended to use a
| combination of ``pyvista`` and ``vtk`` for rapidly computing
| repeated collisions. See the `Collision Detection Example
| <https://kitware.github.io/vtk-examples/site/Python/Visualization/CollisionDetection/>`_
|
| Examples
| --------
| Compute the collision between a sphere and the back faces of a
| cube and output the cell indices of the first 10 collisions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere(radius=0.5)
| >>> mesh_b = pv.Cube(center=(0.5, 0.5, 0.5)).extract_cells([0, 2, 4])
| >>> collision, ncol = mesh_a.collision(mesh_b, cell_tolerance=1)
| >>> collision['ContactCells'][:10]
| pyvista_ndarray([464, 0, 0, 29, 29, 27, 27, 28, 28, 23])
|
| Plot the collisions by creating a collision mask with the
| ``"ContactCells"`` field data. Cells with a collision are
| colored red.
|
| >>> scalars = np.zeros(collision.n_cells, dtype=bool)
| >>> scalars[collision.field_data['ContactCells']] = True
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... collision,
| ... scalars=scalars,
| ... show_scalar_bar=False,
| ... cmap='bwr',
| ... )
| >>> _ = pl.add_mesh(
| ... mesh_b,
| ... color='lightblue',
| ... line_width=5,
| ... opacity=0.7,
| ... show_edges=True,
| ... )
| >>> pl.show()
|
| Alternatively, simply plot the collisions using the default
| ``'collision_rgba'`` array after enabling ``generate_scalars``.
|
| >>> collision, ncol = mesh_a.collision(
| ... mesh_b, cell_tolerance=1, generate_scalars=True
| ... )
| >>> collision.plot()
|
| See :ref:`collision_example` for more examples using this filter.
|
| compute_arc_length(self, progress_bar: 'bool' = False)
| Compute the arc length over the length of the probed line.
|
| It adds a new point-data array named ``"arc_length"`` with the
| computed arc length for each of the polylines in the
| input. For all other cell types, the arc length is set to 0.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| float
| Arc length of the length of the probed line.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> path = sphere.geodesic(0, 100)
| >>> length = path.compute_arc_length()['arc_length'][-1]
| >>> f'Length is {length:.3f}'
| 'Length is 0.812'
|
| This is identical to the geodesic_distance.
|
| >>> length = sphere.geodesic_distance(0, 100)
| >>> f'Length is {length:.3f}'
| 'Length is 0.812'
|
| You can also plot the arc_length.
|
| >>> arc = path.compute_arc_length()
| >>> arc.plot(scalars='arc_length')
|
| compute_normals(self, cell_normals: 'bool' = True, point_normals: 'bool' = True, split_vertices: 'bool' = False, flip_normals: 'bool' = False, consistent_normals: 'bool' = True, auto_orient_normals: 'bool' = False, non_manifold_traversal: 'bool' = True, feature_angle=30.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Compute point and/or cell normals for a mesh.
|
| The filter can reorder polygons to insure consistent
| orientation across polygon neighbors. Sharp edges can be split
| and points duplicated with separate normals to give crisp
| (rendered) surface definition. It is also possible to globally
| flip the normal orientation.
|
| The algorithm works by determining normals for each polygon
| and then averaging them at shared points. When sharp edges are
| present, the edges are split and new points generated to
| prevent blurry edges (due to Phong shading).
|
| An array named ``"Normals"`` is stored with the mesh.
|
| .. warning::
|
| - Normals can only be computed for polygons and triangle strips.
| Point clouds are not supported.
| - Triangle strips are broken up into triangle polygons.
| You may want to restrip the triangles.
| - Previous arrays named ``"Normals"`` will be overwritten.
|
| Parameters
| ----------
| cell_normals : bool, default: True
| Calculation of cell normals.
|
| point_normals : bool, default: True
| Calculation of point normals.
|
| split_vertices : bool, default: False
| Splitting of sharp edges. Indices to the original points are
| tracked in the ``"pyvistaOriginalPointIds"`` array.
|
| flip_normals : bool, default: False
| Set global flipping of normal orientation. Flipping
| modifies both the normal direction and the order of a
| cell's points.
|
| consistent_normals : bool, default: True
| Enforcement of consistent polygon ordering.
|
| auto_orient_normals : bool, default: False
| Turn on/off the automatic determination of correct normal
| orientation. NOTE: This assumes a completely closed
| surface (i.e. no boundary edges) and no non-manifold
| edges. If these constraints do not hold, all bets are
| off. This option adds some computational complexity, and
| is useful if you do not want to have to inspect the
| rendered image to determine whether to turn on the
| ``flip_normals`` flag. However, this flag can work with
| the ``flip_normals`` flag, and if both are set, all the
| normals in the output will point "inward".
|
| non_manifold_traversal : bool, default: True
| Turn on/off traversal across non-manifold edges. Changing
| this may prevent problems where the consistency of
| polygonal ordering is corrupted due to topological
| loops.
|
| feature_angle : float, default: 30.0
| The angle that defines a sharp edge. If the difference in
| angle across neighboring polygons is greater than this
| value, the shared edge is considered "sharp".
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Raises
| ------
| TypeError
| If the mesh contains only ``LINE`` or ``VERTEX`` cell types.
| Normals cannot be computed for these cells.
|
| Returns
| -------
| pyvista.PolyData
| Updated mesh with cell and point normals.
|
| See Also
| --------
| pyvista.PolyData.point_normals
| Returns the array of point normals.
| pyvista.PolyData.cell_normals
| Returns the array of cell normals.
| pyvista.PolyDataFilters.flip_normal_vectors
| Flip cell and point normals.
| pyvista.PolyDataFilters.flip_faces
| Flip the orientation of the faces.
|
| Examples
| --------
| Compute the point normals of the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere = sphere.compute_normals(cell_normals=False)
| >>> normals = sphere['Normals']
| >>> normals.shape
| (842, 3)
|
| Alternatively, create a new mesh when computing the normals
| and compute both cell and point normals.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_with_norm = sphere.compute_normals()
| >>> sphere_with_norm.point_data['Normals'].shape
| (842, 3)
| >>> sphere_with_norm.cell_data['Normals'].shape
| (1680, 3)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| contour_banded(self: 'PolyData', n_contours, rng=None, scalars=None, component=0, clip_tolerance=1e-06, generate_contour_edges: 'bool' = True, scalar_mode='value', clipping: 'bool' = True, progress_bar: 'bool' = False)
| Generate filled contours.
|
| Generates filled contours for :vtk:`vtkPolyData`. Filled contours are
| bands of cells that all have the same cell scalar value, and can
| therefore be colored the same. The method is also referred to as
| filled contour generation.
|
| This filter implements :vtk:`vtkBandedPolyDataContourFilter`.
|
| Parameters
| ----------
| n_contours : int
| Number of contours.
|
| rng : Sequence, optional
| Range of the scalars. Optional and defaults to the minimum and
| maximum of the active scalars of ``scalars``.
|
| scalars : str, optional
| The name of the scalar array to use for contouring. If ``None``,
| the active scalar array will be used.
|
| component : int, default: 0
| The component to use of an input scalars array with more than one
| component.
|
| clip_tolerance : float, default: 1e-6
| Set/Get the clip tolerance. Warning: setting this too large will
| certainly cause numerical issues. Change from the default value at
| your own risk. The actual internal clip tolerance is computed by
| multiplying ``clip_tolerance`` by the scalar range.
|
| generate_contour_edges : bool, default: True
| Controls whether contour edges are generated. Contour edges are
| the edges between bands. If enabled, they are generated from
| polygons/triangle strips and returned as a second output.
|
| scalar_mode : str, default: 'value'
| Control whether the cell scalars are output as an integer index or
| a scalar value. If ``'index'``, the index refers to the bands
| produced by the clipping range. If ``'value'``, then a scalar value
| which is a value between clip values is used.
|
| clipping : bool, default: True
| Indicate whether to clip outside ``rng`` and only return cells with
| values within ``rng``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData
| Surface containing the contour surface.
|
| edges : pyvista.PolyData
| Optional edges when ``generate_contour_edges`` is ``True``.
|
| Examples
| --------
| Plot the random hills dataset and with 8 contour lines. Note how we use 7
| colors here (``n_contours - 1``).
|
| >>> import pyvista as pv
| >>> from pyvista import examples
|
| >>> mesh = examples.load_random_hills()
| >>> n_contours = 8
| >>> _, edges = mesh.contour_banded(n_contours)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... edges,
| ... line_width=5,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(mesh, n_colors=n_contours - 1, cmap='Set3')
| >>> pl.show()
|
| Extract the surface from the uniform grid dataset and plot its contours
| alongside the output from the banded contour filter.
|
| >>> surf = examples.load_uniform().extract_surface(algorithm=None)
| >>> n_contours = 5
| >>> rng = [200, 500]
| >>> output, edges = surf.contour_banded(n_contours, rng=rng)
|
| >>> dargs = dict(n_colors=n_contours - 1, clim=rng)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... edges,
| ... line_width=5,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(surf, opacity=0.3, **dargs)
| >>> _ = pl.add_mesh(output, **dargs)
| >>> pl.show()
|
| curvature(self, curv_type='mean', progress_bar: 'bool' = False)
| Return the pointwise curvature of a mesh.
|
| See :ref:`connectivity_example` for more examples using this
| filter.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| Curvature type. One of the following:
|
| * ``"mean"``
| * ``"gaussian"``
| * ``"maximum"``
| * ``"minimum"``
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Array of curvature values.
|
| Examples
| --------
| Calculate the mean curvature of the hills example mesh and plot it.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> curv = hills.curvature()
| >>> hills.plot(scalars=curv)
|
| Show the curvature array.
|
| >>> curv # doctest:+SKIP
| array([0.20587616, 0.06747695, ..., 0.11781171, 0.15988467])
|
| decimate(self, target_reduction, volume_preservation: 'bool' = False, attribute_error: 'bool | None' = None, scalars: 'bool | None' = None, vectors: 'bool | None' = None, normals: 'bool | None' = None, tcoords: 'bool | None' = None, tensors: 'bool | None' = None, scalars_weight=0.1, vectors_weight=0.1, normals_weight=0.1, tcoords_weight=0.1, tensors_weight=0.1, inplace: 'bool' = False, progress_bar: 'bool' = False, boundary_constraints: 'bool' = False, boundary_weight: 'float' = 1.0, enable_all_attribute_error: 'bool' = False)
| Reduce the number of triangles in a triangular mesh using :vtk:`vtkQuadricDecimation`.
|
| .. versionchanged:: 0.45
| ``scalars``, ``vectors``, ``normals``, ``tcoords`` and ``tensors`` are now disabled by
| default. They can be enabled all together using ``enable_all_attribute_error``.
|
|
| Parameters
| ----------
| target_reduction : float
| Fraction of the original mesh to remove.
| If ``target_reduction`` is set to 0.9, this filter will try
| to reduce the data set to 10% of its original size and will
| remove 90% of the input triangles.
|
| volume_preservation : bool, default: False
| Decide whether to activate volume preservation which greatly
| reduces errors in triangle normal direction. If ``False``,
| volume preservation is disabled and if ``attribute_error``
| is active, these errors can be large.
|
| attribute_error : bool, default: False
| Decide whether to include data attributes in the error metric. If
| ``False``, then only geometric error is used to control the
| decimation. If ``True``, the following flags are used to specify
| which attributes are to be included in the error calculation.
|
| .. deprecated:: 0.45.0
|
| scalars : bool, default: False
| This flags control specifically if the **scalar** attributes
| are to be included in the error calculation.
|
| vectors : bool, default: False
| See ``scalars`` parameter.
|
| normals : bool, default: False
| See ``scalars`` parameter.
| .. versionchanged:: 0.45.0
|
| tcoords : bool, default: False
| See ``scalars`` parameter.
|
| tensors : bool, default: False
| See ``scalars`` parameter.
|
| scalars_weight : float, default: 0.1
| The scaling weight contribution of the scalar attribute.
| These values are used to weight the contribution of the
| attributes towards the error metric.
|
| vectors_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| normals_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| tcoords_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| tensors_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| boundary_constraints: bool, default: False
| Use the legacy weighting by boundary_edge_length instead of by
| boundary_edge_length^2 for backwards compatibility.
| It requires vtk>=9.3.0.
|
| .. versionadded:: 0.45.0
|
| boundary_weight: float, default: 1.0
| A floating point factor to weigh the boundary quadric constraints
| by: higher factors further constrain the boundary.
| It requires vtk>=9.3.0.
|
| .. versionadded:: 0.45.0
|
| enable_all_attribute_error: bool, default: False
| This flag control the default value of all attribute metrics to
| eventually include them in the error calculation
|
| .. versionadded:: 0.45.0
|
| Returns
| -------
| pyvista.PolyData
| Decimated mesh.
|
| See Also
| --------
| decimate_pro
| Another option for triangular meshes.
| decimate_polyline
| For use with polylines.
|
| Notes
| -----
| If you encounter a segmentation fault or other error, consider using
| :func:`pyvista.PolyDataFilters.clean` to remove any invalid cells
| before using this filter.
|
| Examples
| --------
| Decimate a sphere. First plot the sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=60, theta_resolution=60)
| >>> sphere.plot(show_edges=True, line_width=2)
|
| Now decimate it by 75% and plot it.
|
| >>> decimated = sphere.decimate(0.75)
| >>> decimated.plot(show_edges=True, line_width=2)
|
| Decimate taking scalars attributes into account:
|
| >>> decimated = sphere.decimate(0.5, scalars=True)
|
| Decimate taking all attributes **except** normals into account:
|
| >>> decimated = sphere.decimate(
| ... 0.5, enable_all_attribute_error=True, normals=False
| ... )
|
| See :ref:`decimate_example` for more examples using this filter.
|
| decimate_polyline(self, reduction: 'float', *, maximum_error: 'float' = 10.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Reduce the number of lines in a polyline mesh.
|
| This filter uses :vtk:`vtkDecimatePolylineFilter`.
|
| .. versionadded:: 0.45.0
|
| Parameters
| ----------
| reduction : float
| Reduction factor. A value of 0.9 will leave 10% of the
| original number of vertices.
|
| maximum_error : float, default: 10.
| Fraction of the maximum length of the input data bounding box
| to limit reduction. This might prevent the full reduction from
| being achieved. Default of ``10.`` should not limit reduction.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated mesh.
|
| Warnings
| --------
| From :vtk:`vtkDecimatePolylineFilter` documentation: this algorithm is a very
| simple implementation that overlooks some potential complexities.
| For example, if a vertex is multiply connected, meaning that it is
| used by multiple distinct polylines, then the extra topological
| constraints are ignored. This can produce less than optimal results.
|
| See Also
| --------
| decimate
| For use with triangular meshes.
| decimate_pro
| Another option for triangular meshes.
|
| Examples
| --------
| Generate a circle, builtin function returns a Polygon cell.
|
| >>> import pyvista as pv
| >>> circle = pv.Circle(resolution=30)
|
| Convert to a Polyline. A polyline requires duplicating reference
| to initial point to close the circle.
|
| >>> circle_polyline = pv.PolyData(
| ... circle.points, lines=[31] + list(range(30)) + [0]
| ... )
| >>> circle_polyline.n_points
| 30
|
| Decimate ~50% of points.
|
| >>> decimate_some = circle_polyline.decimate_polyline(0.5)
| >>> decimate_some.n_points
| 14
|
| Decimate more points.
|
| >>> decimate_more = circle_polyline.decimate_polyline(0.75)
| >>> decimate_more.n_points
| 6
|
| Compare decimated polylines.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(circle_polyline, label='Circle', color='red', line_width=5)
| >>> _ = pl.add_mesh(
| ... decimate_some,
| ... label='Decimated some',
| ... color='blue',
| ... line_width=5,
| ... )
| >>> _ = pl.add_mesh(
| ... decimate_more,
| ... label='Decimated more',
| ... color='black',
| ... line_width=5,
| ... )
| >>> pl.view_xy()
| >>> _ = pl.add_legend(face='line', size=(0.25, 0.25))
| >>> pl.show()
|
| See :ref:`decimate_example` for more examples using this filter.
|
| decimate_pro(self, reduction, feature_angle=45.0, split_angle=75.0, splitting: 'bool' = True, pre_split_mesh: 'bool' = False, preserve_topology: 'bool' = False, boundary_vertex_deletion: 'bool' = True, max_degree=None, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Reduce the number of triangles in a triangular mesh.
|
| It forms a good approximation to the original geometry. Based
| on the algorithm originally described in "Decimation of
| Triangle Meshes", Proc Siggraph 92
| (https://doi.org/10.1145/133994.134010).
|
| Parameters
| ----------
| reduction : float
| Reduction factor. A value of 0.9 will leave 10% of the
| original number of vertices.
|
| feature_angle : float, default: 45.0
| Angle used to define what an edge is (i.e., if the surface
| normal between two adjacent triangles is >= ``feature_angle``,
| an edge exists).
|
| split_angle : float, default: 75.0
| Angle used to control the splitting of the mesh. A split
| line exists when the surface normals between two edge
| connected triangles are >= ``split_angle``.
|
| splitting : bool, default: True
| Controls the splitting of the mesh at corners, along
| edges, at non-manifold points, or anywhere else a split is
| required. Turning splitting off will better preserve the
| original topology of the mesh, but may not necessarily
| give the exact requested decimation.
|
| pre_split_mesh : bool, default: False
| Separates the mesh into semi-planar patches, which are
| disconnected from each other. This can give superior
| results in some cases. If ``pre_split_mesh`` is set to
| ``True``, the mesh is split with the specified
| ``split_angle``. Otherwise mesh splitting is deferred as
| long as possible.
|
| preserve_topology : bool, default: False
| Controls topology preservation. If on, mesh splitting and
| hole elimination will not occur. This may limit the
| maximum reduction that may be achieved.
|
| boundary_vertex_deletion : bool, default: True
| Allow deletion of vertices on the boundary of the mesh.
| Turning this off may limit the maximum reduction that may
| be achieved.
|
| max_degree : float, optional
| The maximum vertex degree. If the number of triangles
| connected to a vertex exceeds ``max_degree``, then the
| vertex will be split. The complexity of the triangulation
| algorithm is proportional to ``max_degree**2``. Setting ``max_degree``
| small can improve the performance of the algorithm.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated mesh.
|
| See Also
| --------
| decimate
| Another option for triangular meshes.
| decimate_polyline
| For use with polylines.
|
| Examples
| --------
| Decimate a sphere. First plot the sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=60, theta_resolution=60)
| >>> sphere.plot(show_edges=True, line_width=2)
|
| Now decimate it and plot it.
|
| >>> decimated = sphere.decimate_pro(0.75)
| >>> decimated.plot(show_edges=True, line_width=2)
|
| See :ref:`decimate_example` for more examples using this filter.
|
| delaunay_2d(self, tol=1e-05, alpha=0.0, offset=1.0, bound: 'bool' = False, inplace: 'bool' = False, edge_source=None, progress_bar: 'bool' = False)
| Apply a 2D Delaunay filter along the best fitting plane.
|
| This filter can be used to generate a 2d surface from a set of
| points on a plane. If you want to create a surface from a
| point cloud, see :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| tol : float, default: 1e-05
| Specify a tolerance to control discarding of closely
| spaced points. This tolerance is specified as a fraction
| of the diagonal length of the bounding box of the points.
|
| alpha : float, default: 0.0
| Specify alpha (or distance) value to control output of
| this filter. For a non-zero alpha value, only edges or
| triangles contained within a sphere centered at mesh
| vertices will be output. Otherwise, only triangles will be
| output.
|
| offset : float, default: 1.0
| Specify a multiplier to control the size of the initial,
| bounding Delaunay triangulation.
|
| bound : bool, default: False
| Boolean controls whether bounding triangulation points
| and associated triangles are included in the
| output. These are introduced as an initial triangulation
| to begin the triangulation process. This feature is nice
| for debugging output.
|
| inplace : bool, default: False
| If ``True``, overwrite this mesh with the triangulated
| mesh.
|
| edge_source : pyvista.PolyData, optional
| Specify the source object used to specify constrained
| edges and loops. If set, and lines/polygons are defined, a
| constrained triangulation is created. The lines/polygons
| are assumed to reference points in the input point set
| (i.e. point ids are identical in the input and
| source).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh from the 2D delaunay filter.
|
| Examples
| --------
| First, generate 30 points on circle and plot them.
|
| >>> import pyvista as pv
| >>> points = pv.Polygon(n_sides=30).points
| >>> circle = pv.PolyData(points)
| >>> circle.plot(show_edges=True, point_size=15)
|
| Use :func:`delaunay_2d` to fill the interior of the circle.
|
| >>> filled_circle = circle.delaunay_2d()
| >>> filled_circle.plot(show_edges=True, line_width=5)
|
| Use the ``edge_source`` parameter to create a constrained delaunay
| triangulation and plot it.
|
| >>> squar = pv.Polygon(n_sides=4, radius=8, fill=False)
| >>> squar = squar.rotate_z(45, inplace=False)
| >>> circ0 = pv.Polygon(center=(2, 3, 0), n_sides=30, radius=1)
| >>> circ1 = pv.Polygon(center=(-2, -3, 0), n_sides=30, radius=1)
| >>> comb = circ0.append_polydata(circ1, squar)
| >>> tess = comb.delaunay_2d(edge_source=comb)
| >>> tess.plot(cpos='xy', show_edges=True)
|
| See :ref:`create_tri_surface_example` for more examples using this filter.
|
| edge_mask(self, angle, progress_bar: 'bool' = False)
| Return a mask of the points of a surface mesh with a surface angle greater than angle.
|
| Parameters
| ----------
| angle : float
| Angle to consider an edge.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Mask of points with an angle greater than ``angle``.
|
| Examples
| --------
| Plot the mask of points that exceed 45 degrees.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube().triangulate().subdivide(4)
| >>> mask = mesh.edge_mask(45)
| >>> mesh.plot(scalars=mask)
|
| Show the array of masked points.
|
| >>> mask # doctest:+SKIP
| array([ True, True, True, ..., False, False, False])
|
| extrude(self, vector, capping=None, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Sweep polygonal data creating a "skirt" from free edges.
|
| This will create a line from vertices.
|
| This takes polygonal data as input and generates polygonal
| data on output. The input dataset is swept according to some
| extrusion function and creates new polygonal primitives. These
| primitives form a "skirt" or swept surface. For example,
| sweeping a line results in a quadrilateral, and sweeping a
| triangle creates a "wedge".
|
| The skirt is generated by locating certain topological
| features. Free edges (edges of polygons or triangle strips
| only used by one polygon or triangle strips) generate
| surfaces. This is true also of lines or polylines. Vertices
| generate lines.
|
| .. versionchanged:: 0.32.0
| The ``capping`` keyword was added with a default of ``False``.
| The previously used VTK default corresponds to ``capping=True``.
| In a future version the default will be changed to ``True`` to
| match the behavior of the underlying VTK filter.
|
| Parameters
| ----------
| vector : numpy.ndarray or sequence
| Direction and length to extrude the mesh in.
|
| capping : bool, optional
| Control if the sweep of a 2D object is capped. The default is
| ``False``, which differs from VTK's default.
|
| .. warning::
| The ``capping`` keyword was added in version 0.32.0 with a
| default value of ``False``. In a future version this default
| will be changed to ``True`` to match the behavior of the
| underlying VTK filter. It is recommended to explicitly pass
| a value for this keyword argument to prevent future changes
| in behavior and warnings.
|
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extruded mesh.
|
| Examples
| --------
| Extrude a half circle arc.
|
| >>> import pyvista as pv
| >>> arc = pv.CircularArc(pointa=[-1, 0, 0], pointb=[1, 0, 0], center=[0, 0, 0])
| >>> mesh = arc.extrude([0, 0, 1], capping=False)
| >>> mesh.plot(color='lightblue')
|
| Extrude and cap an 8 sided polygon.
|
| >>> poly = pv.Polygon(n_sides=8)
| >>> mesh = poly.extrude((0, 0, 1.5), capping=True)
| >>> mesh.plot(line_width=5, show_edges=True)
|
| extrude_rotate(self, resolution=30, inplace: 'bool' = False, translation=0.0, dradius=0.0, angle=360.0, capping=None, rotation_axis=(0, 0, 1), progress_bar: 'bool' = False)
| Sweep polygonal data creating "skirt" from free edges/lines, and lines from vertices.
|
| This takes polygonal data as input and generates polygonal
| data on output. The input dataset is swept around the axis
| to create new polygonal primitives. These primitives form a
| "skirt" or swept surface. For example, sweeping a line results
| in a cylindrical shell, and sweeping a circle creates a torus.
|
| There are a number of control parameters for this filter. You
| can control whether the sweep of a 2D object (i.e., polygon or
| triangle strip) is capped with the generating geometry via the
| ``capping`` parameter. Also, you can control the angle of
| rotation, and whether translation along the axis is
| performed along with the rotation. (Translation is useful for
| creating "springs".) You also can adjust the radius of the
| generating geometry with the ``dradius`` parameter.
|
| The skirt is generated by locating certain topological
| features. Free edges (edges of polygons or triangle strips
| only used by one polygon or triangle strips) generate
| surfaces. This is true also of lines or polylines. Vertices
| generate lines.
|
| This filter can be used to model axisymmetric objects like
| cylinders, bottles, and wine glasses; or translational
| rotational symmetric objects like springs or corkscrews.
|
| .. versionchanged:: 0.32.0
| The ``capping`` keyword was added with a default of ``False``.
| The previously used VTK default corresponds to ``capping=True``.
| In a future version the default will be changed to ``True`` to
| match the behavior of the underlying VTK filter.
|
| Parameters
| ----------
| resolution : int, optional
| Number of pieces to divide line into.
|
| inplace : bool, default: False
| Overwrites the original mesh inplace.
|
| translation : float, optional
| Total amount of translation along the axis.
|
| dradius : float, optional
| Change in radius during sweep process.
|
| angle : float, optional
| The angle of rotation in degrees.
|
| capping : bool, optional
| Control if the sweep of a 2D object is capped. The default is
| ``False``, which differs from VTK's default.
|
| .. warning::
| The ``capping`` keyword was added in version 0.32.0 with a
| default value of ``False``. In a future version this default
| will be changed to ``True`` to match the behavior of the
| underlying VTK filter. It is recommended to explicitly pass
| a value for this keyword argument to prevent future changes
| in behavior and warnings.
|
| rotation_axis : numpy.ndarray or sequence, optional
| The direction vector of the axis around which the rotation is done.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Rotationally extruded mesh.
|
| See Also
| --------
| :ref:`extrude_rotate_example`
|
| Examples
| --------
| Create a "spring" using the rotational extrusion filter.
|
| >>> import pyvista as pv
| >>> profile = pv.Polygon(
| ... center=[1.25, 0.0, 0.0],
| ... radius=0.2,
| ... normal=(0, 1, 0),
| ... n_sides=30,
| ... )
| >>> extruded = profile.extrude_rotate(
| ... resolution=360,
| ... translation=4.0,
| ... dradius=0.5,
| ... angle=1500.0,
| ... capping=True,
| ... )
| >>> extruded.plot(smooth_shading=True)
|
| Create a "wine glass" using the rotational extrusion filter.
|
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [-0.18, 0, 0],
| ... [-0.18, 0, 0.01],
| ... [-0.18, 0, 0.02],
| ... [-0.01, 0, 0.03],
| ... [-0.01, 0, 0.04],
| ... [-0.02, 0, 0.5],
| ... [-0.05, 0, 0.75],
| ... [-0.1, 0, 0.8],
| ... [-0.2, 0, 1.0],
| ... ]
| ... )
| >>> spline = pv.Spline(points, 30)
| >>> extruded = spline.extrude_rotate(resolution=20, capping=False)
| >>> extruded.plot(color='lightblue')
|
| extrude_trim(self, direction, trim_surface, extrusion='boundary_edges', capping='intersection', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extrude polygonal data trimmed by a surface.
|
| The input dataset is swept along a specified direction forming a
| "skirt" from the boundary edges 2D primitives (i.e., edges used
| by only one polygon); and/or from vertices and lines. The extent
| of the sweeping is defined where the sweep intersects a
| user-specified surface.
|
| Parameters
| ----------
| direction : numpy.ndarray or sequence
| Direction vector to extrude.
|
| trim_surface : pyvista.PolyData
| Surface which trims the surface.
|
| extrusion : str, default: "boundary_edges"
| Control the strategy of extrusion. One of the following:
|
| * ``"boundary_edges"``
| * ``"all_edges"``
|
| The default only generates faces on the boundary of the original
| input surface. When using ``"all_edges"``, faces are created along
| interior points as well.
|
| capping : str, default: "intersection"
| Control the strategy of capping. One of the following:
|
| * ``"intersection"``
| * ``"minimum_distance"``
| * ``"maximum_distance"``
| * ``"average_distance"``
|
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extruded mesh trimmed by a surface.
|
| See Also
| --------
| :ref:`extrude_trim_example`
|
| Examples
| --------
| Extrude a disc.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> plane = pv.Plane(i_size=2, j_size=2, direction=[0, 0.8, 1])
| >>> disc = pv.Disc(center=(0, 0, -1), c_res=50)
| >>> direction = [0, 0, 1]
| >>> extruded_disc = disc.extrude_trim(direction, plane)
| >>> extruded_disc.plot(smooth_shading=True, split_sharp_edges=True)
|
| fill_holes(self, hole_size, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Fill holes in a :class:`pyvista.PolyData` or :vtk:`vtkPolyData` object.
|
| Holes are identified by locating boundary edges, linking them
| together into loops, and then triangulating the resulting
| loops. Note that you can specify an approximate limit to the
| size of the hole that can be filled.
|
| .. warning::
| This method is known to segfault. Use at your own risk.
|
| Parameters
| ----------
| hole_size : float
| Specifies the maximum hole size to fill. This is
| represented as a radius to the bounding circumsphere
| containing the hole. Note that this is an approximate
| area; the actual area cannot be computed without first
| triangulating the hole.
|
| inplace : bool, default: False
| Return new mesh or overwrite input.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh with holes filled if ``inplace=False``.
|
| Examples
| --------
| Create a partial sphere with a hole and then fill it.
|
| >>> import pyvista as pv
| >>> sphere_with_hole = pv.Sphere(end_theta=330)
| >>> sphere = sphere_with_hole.fill_holes(1000) # doctest:+SKIP
| >>> edges = sphere.extract_feature_edges(
| ... feature_edges=False, manifold_edges=False
| ... ) # doctest:+SKIP
| >>> assert edges.n_cells == 0 # doctest:+SKIP
|
| See :ref:`fill_holes_example` for more examples using this filter.
|
| flip_faces(self: 'PolyData', *, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Flip the orientation of the faces.
|
| The flip is performed by reversing the order of indices in the cell
| connectivity list. In other libraries, this operation is sometimes
| referred to as "flip orientation", "reverse cells", "reverse face
| orientations", or similar.
|
| .. note::
|
| Polygon cells have an implicitly-defined orientation, and reversing
| the ordering affects how normals are computed by filters like
| :meth:`~pyvista.PolyDataFilters.compute_normals`.
|
| .. note::
| This filter does not modify any existing normals which may be present
| in the dataset. Use :meth:`~pyvista.PolyDataFilters.flip_normal_vectors`
| to flip the normal vectors.
|
| .. warning::
|
| This filter does not produce the correct output for
| :attr:`~pyvista.CellType.TRIANGLE_STRIP` cells,
| see https://gitlab.kitware.com/vtk/vtk/-/issues/18634.
| Use :meth:`~pyvista.PolyDataFilters.triangulate` to triangulate the mesh
| first.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh with flipped faces.
|
| See Also
| --------
| pyvista.PolyDataFilters.flip_normal_vectors
| Flip the direction of the point and cell normals.
| pyvista.PolyDataFilters.compute_normals
| Compute new normals. Includes the option to flip the normals.
| pyvista.PolyData.point_normals
| Returns the array of point normals.
| pyvista.PolyData.cell_normals
| Returns the array of cell normals.
|
| Examples
| --------
| Flip the faces of a sphere. Show the point ids of the first cell
| before and after the flip.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.regular_faces[0]
| array([ 2, 30, 0])
|
| >>> sphere_flipped = sphere.flip_faces()
| >>> sphere_flipped.regular_faces[0]
| array([ 0, 30, 2])
|
| Note that the sphere also has pre-computed normals which have not been
| affected by this filter.
|
| >>> sphere.point_data['Normals'][0]
| pyvista_ndarray([0., 0., 1.], dtype=float32)
|
| >>> sphere_flipped.point_data['Normals'][0]
| pyvista_ndarray([0., 0., 1.], dtype=float32)
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| flip_normal_vectors(self: 'PolyData', *, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Flip the direction of the mesh's point and cell normal vectors.
|
| This filter effectively multiplies the point and cell normals by ``-1``.
| It has no effect if no active normals are currently set.
|
| .. note::
|
| Polygon cells have an implicitly-defined orientation which may differ
| from the orientation of the normal vectors. To ensure that the normals
| are consistent with this implicit definition, consider also using
| :meth:`~pyvista.PolyDataFilters.flip_faces` or re-computing normals with
| :meth:`~pyvista.PolyDataFilters.compute_normals` and enabling the
| `flip_normals` option.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh with point and cell normal directions flipped.
|
| See Also
| --------
| pyvista.PolyDataFilters.flip_faces
| Flip the orientation of the faces.
| pyvista.PolyDataFilters.compute_normals
| Compute new normals. Includes the option to flip the normals.
| pyvista.PolyData.point_normals
| Returns the array of point normals.
| pyvista.PolyData.cell_normals
| Returns the array of cell normals.
|
| Examples
| --------
| Flip the normal vectors of a sphere. Show one of the normal vectors
| before and after the flip.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.point_data['Normals'][0]
| pyvista_ndarray([0., 0., 1.], dtype=float32)
|
| >>> sphere_flipped = sphere.flip_normal_vectors()
| >>> sphere_flipped.point_data['Normals'][0]
| pyvista_ndarray([-0., -0., -1.], dtype=float32)
|
| Note that the sphere's cell ordering has not been affected by this filter.
|
| >>> sphere.regular_faces[0]
| array([ 2, 30, 0])
|
| >>> sphere_flipped.regular_faces[0]
| array([ 2, 30, 0])
|
| flip_normals(self)
| Flip normals of a triangular mesh by reversing the point ordering.
|
| .. deprecated:: 0.45
|
| This filter is deprecated. Use ``flip_faces(inplace=True)`` instead.
|
| Examples
| --------
| Flip the normals of a sphere and plot the normals before and
| after the flip.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.plot_normals(mag=0.1)
| >>> sphere.flip_normals() # doctest:+SKIP
| >>> sphere.plot_normals(mag=0.1, opacity=0.5)
|
| geodesic(self, start_vertex, end_vertex, inplace: 'bool' = False, keep_order: 'bool' = True, use_scalar_weights: 'bool' = False, progress_bar: 'bool' = False)
| Calculate the geodesic path between two vertices using Dijkstra's algorithm.
|
| This will add an array titled ``'vtkOriginalPointIds'`` of the input
| mesh's point ids to the output mesh. The default behavior of the
| underlying :vtk:`vtkDijkstraGraphGeodesicPath` filter is that the
| geodesic path is reversed in the resulting mesh. This is overridden
| in PyVista by default.
|
| Parameters
| ----------
| start_vertex : int
| Vertex index indicating the start point of the geodesic segment.
|
| end_vertex : int
| Vertex index indicating the end point of the geodesic segment.
|
| inplace : bool, default: False
| Whether the input mesh should be replaced with the path. The
| geodesic path is always returned.
|
| keep_order : bool, default: True
| If ``True``, the points of the returned path are guaranteed
| to start with the start vertex (as opposed to the end vertex).
|
| .. versionadded:: 0.32.0
|
| use_scalar_weights : bool, default: False
| If ``True``, use scalar values in the edge weight.
| This only works for point data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| ``PolyData`` object consisting of the line segment between the
| two given vertices. If ``inplace`` is ``True`` this is the
| same object as the input mesh.
|
| Examples
| --------
| Plot the path between two points on the random hills mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> path = hills.geodesic(560, 5820)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills)
| >>> _ = pl.add_mesh(path, line_width=5, color='k')
| >>> pl.show()
|
| See :ref:`geodesic_example` for more examples using this filter.
|
| geodesic_distance(self, start_vertex, end_vertex, use_scalar_weights: 'bool' = False, progress_bar: 'bool' = False)
| Calculate the geodesic distance between two vertices using Dijkstra's algorithm.
|
| Parameters
| ----------
| start_vertex : int
| Vertex index indicating the start point of the geodesic segment.
|
| end_vertex : int
| Vertex index indicating the end point of the geodesic segment.
|
| use_scalar_weights : bool, default: False
| If ``True``, use scalar values in the edge weight.
| This only works for point data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| float
| Length of the geodesic segment.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> length = sphere.geodesic_distance(0, 100)
| >>> f'Length is {length:.3f}'
| 'Length is 0.812'
|
| See :ref:`geodesic_example` for more examples using this filter.
|
| intersection(self, mesh, split_first: 'bool' = True, split_second: 'bool' = True, progress_bar: 'bool' = False)
| Compute the intersection between two meshes.
|
| .. note::
| This method returns the surface intersection from two meshes
| (which often resolves as a line), whereas the
| :func:`PolyDataFilters.boolean_intersection` filter returns
| the "volume" intersection between two closed (manifold)
| meshes.
|
| Parameters
| ----------
| mesh : pyvista.PolyData
| The mesh to intersect with.
|
| split_first : bool, default: True
| If ``True``, return the first input mesh split by the
| intersection with the second input mesh.
|
| split_second : bool, default: True
| If ``True``, return the second input mesh split by the
| intersection with the first input mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The intersection line.
|
| pyvista.PolyData
| The first mesh split along the intersection. Returns the
| original first mesh if ``split_first=False``.
|
| pyvista.PolyData
| The second mesh split along the intersection. Returns the
| original second mesh if ``split_second=False``.
|
| Examples
| --------
| Intersect two spheres, returning the intersection and both spheres
| which have new points/cells along the intersection line.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> s1 = pv.Sphere(phi_resolution=15, theta_resolution=15)
| >>> s2 = s1.copy()
| >>> s2.points += np.array([0.25, 0, 0])
| >>> intersection, s1_split, s2_split = s1.intersection(s2)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(s1, style='wireframe')
| >>> _ = pl.add_mesh(s2, style='wireframe')
| >>> _ = pl.add_mesh(intersection, color='r', line_width=10)
| >>> pl.show()
|
| The mesh splitting takes additional time and can be turned
| off for either mesh individually.
|
| >>> intersection, _, s2_split = s1.intersection(
| ... s2, split_first=False, split_second=True
| ... )
|
| merge(self: 'PolyData', dataset, merge_points: 'bool' = True, tolerance=0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Merge this mesh with one or more datasets.
|
| .. note::
| The behavior of this filter varies from the
| :func:`PolyDataFilters.boolean_union` filter. This filter
| does not attempt to create a manifold mesh and will include
| internal surfaces when two meshes overlap.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the other mesh is also a
| :class:`pyvista.PolyData`, in-place merging via ``+=`` is
| similarly possible.
|
| .. versionchanged:: 0.39.0
| Before version ``0.39.0``, if all input datasets were of type
| :class:`pyvista.PolyData`, the VTK :vtk:`vtkAppendPolyData` and
| :vtk:`vtkCleanPolyData` filters were used to perform merging.
| Otherwise, :func:`DataSetFilters.merge`, which uses the VTK
| :vtk:`vtkAppendFilter` filter, was called.
| To enhance performance and coherence with merging operations
| available for other datasets in pyvista, the merging operation
| has been delegated in ``0.39.0`` to :func:`DataSetFilters.merge`
| only, irrespectively of input datasets types.
| This induced that points ordering can be altered compared to
| previous pyvista versions when merging only PolyData together.
| To obtain similar results as before ``0.39.0`` for multiple PolyData, combine
| :func:`PolyDataFilters.append_polydata` and :func:`PolyDataFilters.clean`.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| .. seealso::
| :func:`PolyDataFilters.append_polydata`
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| PyVista dataset to merge this mesh with.
|
| merge_points : bool, optional
| Merge equivalent points when ``True``.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when ``True`` if the input type is a
| :class:`pyvista.PolyData`. For other input meshes the
| result is a :class:`pyvista.UnstructuredGrid` which makes
| in-place operation impossible.
|
| main_has_priority : bool, optional
| When this parameter is ``True`` and ``merge_points=True``,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| :class:`pyvista.PolyData` if ``dataset`` is a
| :class:`pyvista.PolyData`, otherwise a
| :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> merged = sphere_a.merge(sphere_b)
| >>> merged.plot(style='wireframe', color='lightblue')
|
| multi_ray_trace(self: 'PolyData', origins, directions, first_point: 'bool' = False, retry: 'bool' = False)
| Perform multiple ray trace calculations.
|
| This requires a mesh with only triangular faces, an array of
| origin points and an equal sized array of direction vectors to
| trace along.
|
| The embree library used for vectorization of the ray traces is
| known to occasionally return no intersections where the VTK
| implementation would return an intersection. If the result
| appears to be missing some intersection points, set
| ``retry=True`` to run a second pass over rays that returned no
| intersections, using :func:`PolyDataFilters.ray_trace`.
|
| Parameters
| ----------
| origins : array_like[float]
| Starting point for each trace.
|
| directions : array_like[float]
| Direction vector for each trace.
|
| first_point : bool, default: False
| Returns intersection of first point only.
|
| retry : bool, default: False
| Will retry rays that return no intersections using
| :func:`PolyDataFilters.ray_trace`.
|
| Returns
| -------
| intersection_points : numpy.ndarray
| Location of the intersection points. Empty array if no
| intersections.
|
| intersection_rays : numpy.ndarray
| Indices of the ray for each intersection point. Empty array if no
| intersections.
|
| intersection_cells : numpy.ndarray
| Indices of the intersection cells. Empty array if no
| intersections.
|
| Examples
| --------
| Compute the intersection between rays from the origin in
| directions ``[1, 0, 0]``, ``[0, 1, 0]`` and ``[0, 0, 1]``, and
| a sphere with radius 0.5 centered at the origin
|
| >>> import pyvista as pv # doctest:+SKIP
| >>> sphere = pv.Sphere() # doctest:+SKIP
| >>> points, rays, cells = sphere.multi_ray_trace(
| ... [[0, 0, 0]] * 3,
| ... [[1, 0, 0], [0, 1, 0], [0, 0, 1]],
| ... first_point=True,
| ... ) # doctest:+SKIP
| >>> string = ', '.join(
| ... [
| ... f'({point[0]:.3f}, {point[1]:.3f}, {point[2]:.3f})'
| ... for point in points
| ... ]
| ... ) # doctest:+SKIP
| >>> f'Rays intersected at {string}' # doctest:+SKIP
| 'Rays intersected at (0.499, 0.000, 0.000), (0.000, 0.497, 0.000), (0.000, 0.000, 0.500)'
|
| plot_boundaries(self: 'PolyData', edge_color='red', line_width=None, progress_bar: 'bool' = False, **kwargs)
| Plot boundaries of a mesh.
|
| Parameters
| ----------
| edge_color : ColorLike, default: "red"
| The color of the edges when they are added to the plotter.
|
| line_width : int, optional
| Width of the boundary lines.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| All additional keyword arguments will be passed to
| :func:`pyvista.Plotter.add_mesh`.
|
| Returns
| -------
| pyvista.CameraPosition
| List of camera position, focal point, and view up.
| Returned when ``return_cpos`` is ``True``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot_boundaries(line_width=10)
|
| plot_curvature(self, curv_type='mean', **kwargs)
| Plot the curvature.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| One of the following strings indicating curvature type:
|
| * ``'mean'``
| * ``'gaussian'``
| * ``'maximum'``
| * ``'minimum'``
|
| **kwargs : dict, optional
| See :func:`pyvista.plot`.
|
| Returns
| -------
| pyvista.CameraPosition
| List of camera position, focal point, and view up.
| Returned when ``return_cpos`` is ``True``.
|
| Examples
| --------
| Plot the Gaussian curvature of an example mesh. Override the
| default scalar bar range as the mesh edges report high
| curvature.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot_curvature(
| ... curv_type='gaussian', smooth_shading=True, clim=[0, 1]
| ... )
|
| plot_normals(self: 'PolyData', show_mesh: 'bool' = True, mag=1.0, flip: 'bool' = False, use_every=1, faces: 'bool' = False, color=None, **kwargs)
| Plot the point normals of a mesh.
|
| Parameters
| ----------
| show_mesh : bool, default: True
| Plot the mesh itself.
|
| mag : float, default: 1.0
| Size magnitude of the normal arrows.
|
| flip : bool, default: False
| Flip the normal direction when ``True``.
|
| use_every : int, default: 1
| Display every nth normal. By default every normal is
| displayed. Display every 10th normal by setting this
| parameter to 10.
|
| faces : bool, default: False
| Plot face normals instead of the default point normals.
|
| color : ColorLike, optional
| Color of the arrows. Defaults to
| :attr:`pyvista.plotting.themes.Theme.edge_color`.
|
| **kwargs : dict, optional
| All additional keyword arguments will be passed to
| :func:`pyvista.Plotter.add_mesh`.
|
| Returns
| -------
| pyvista.CameraPosition
| List of camera position, focal point, and view up.
| Returned when ``return_cpos`` is ``True``.
|
| Examples
| --------
| Plot the point normals of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=10, theta_resolution=10)
| >>> sphere.plot_normals(mag=0.1, show_edges=True)
|
| Plot the face normals of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=10, theta_resolution=10)
| >>> sphere.plot_normals(mag=0.1, faces=True, show_edges=True)
|
| project_points_to_plane(self: 'PolyData', origin: 'VectorLike[float] | None' = None, normal: 'VectorLike[float] | _NormalsLiteral | None' = None, inplace: 'bool' = False, plane: 'PolyData | None' = None)
| Project points of this mesh to a plane.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| Parameters
| ----------
| origin : VectorLike[float], optional
| Plane origin. Defaults to the approximate center of the
| input mesh minus half the length of the input mesh in the
| direction of the normal.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector for the plane's normal. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'z'`` direction is used by default.
|
| inplace : bool, default: False
| Whether to overwrite the original mesh with the projected
| points.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to project to. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| The points of this mesh projected onto a plane.
|
| See Also
| --------
| :ref:`project_plane_example`
| :ref:`project_points_tessellate_example`
|
| Examples
| --------
| Flatten a sphere to the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> projected = sphere.project_points_to_plane()
|
| Plot the projected sphere along with the original.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(projected, show_edges=True, line_width=3)
| >>> _ = pl.add_mesh(sphere)
| >>> _ = pl.show_grid()
| >>> cpos = pv.CameraPosition(
| ... position=(2.5, 2.5, 1.1),
| ... focal_point=(0.0, 0.0, -0.3),
| ... viewup=(-0.25, -0.25, 1.0),
| ... )
| >>> pl.camera_position = cpos
| >>> pl.show()
|
| protein_ribbon(self, progress_bar: 'bool' = False)
| Generate protein ribbon.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Generated protein ribbon.
|
| Examples
| --------
| Generate protein ribbon.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> tgqp = examples.download_3gqp()
| >>> ribbon = tgqp.protein_ribbon()
| >>> ribbon.plot()
|
| ray_trace(self: 'PolyData', origin, end_point, first_point: 'bool' = False, plot: 'bool' = False, off_screen=None)
| Perform a single ray trace calculation.
|
| This requires a mesh and a line segment defined by an origin
| and end_point.
|
| .. warning::
|
| This filter uses the mesh's :attr:`~pyvista.PolyData.obbTree` property internally to
| compute the intersection. Since the obb tree is cached, the intersection may not be
| valid if the mesh's geometry is modified in between filter calls.
|
| Parameters
| ----------
| origin : sequence[float]
| Start of the line segment.
|
| end_point : sequence[float]
| End of the line segment.
|
| first_point : bool, default: False
| Returns intersection of first point only.
|
| plot : bool, default: False
| Whether to plot the ray trace results.
|
| off_screen : bool, optional
| Plots off screen when ``plot=True``. Used for unit testing.
|
| Returns
| -------
| intersection_points : numpy.ndarray
| Location of the intersection points. Empty array if no
| intersections.
|
| intersection_cells : numpy.ndarray
| Indices of the intersection cells. Empty array if no
| intersections.
|
| See Also
| --------
| :ref:`ray_trace_moeller_example`
| Example of ray-tracing using the Moeller-Trumbore intersection algorithm.
|
| Examples
| --------
| Compute the intersection between a ray from the origin to
| ``[1, 0, 0]`` and a sphere with radius 0.5 centered at the
| origin.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> point, cell = sphere.ray_trace([0, 0, 0], [1, 0, 0], first_point=True)
| >>> f'Intersected at {point[0]:.3f} {point[1]:.3f} {point[2]:.3f}'
| 'Intersected at 0.499 0.000 0.000'
|
| Show a plot of the ray trace.
|
| >>> point, cell = sphere.ray_trace([0, 0, 0], [1, 0, 0], plot=True)
|
| See :ref:`ray_trace_example` for more examples using this filter.
|
| reconstruct_surface(self, nbr_sz=None, sample_spacing=None, progress_bar: 'bool' = False)
| Reconstruct a surface from the points in this dataset.
|
| This filter takes a list of points assumed to lie on the
| surface of a solid 3D object. A signed measure of the distance
| to the surface is computed and sampled on a regular grid. The
| grid can then be contoured at zero to extract the surface. The
| default values for neighborhood size and sample spacing should
| give reasonable results for most uses but can be set if
| desired.
|
| This is helpful when generating surfaces from point clouds and
| is more reliable than :func:`DataSetFilters.delaunay_3d`.
|
| Parameters
| ----------
| nbr_sz : int, optional
| Specify the number of neighbors each point has, used for
| estimating the local surface orientation.
|
| The default value of 20 should be fine for most
| applications, higher values can be specified if the spread
| of points is uneven. Values as low as 10 may yield
| adequate results for some surfaces. Higher values cause
| the algorithm to take longer and will cause
| errors on sharp boundaries.
|
| sample_spacing : float, optional
| The spacing of the 3D sampling grid. If not set, a
| reasonable guess will be made.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Reconstructed surface.
|
| Examples
| --------
| Create a point cloud out of a sphere and reconstruct a surface
| from it.
|
| >>> import pyvista as pv
| >>> points = pv.wrap(pv.Sphere().points)
| >>> surf = points.reconstruct_surface()
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(points)
| >>> _ = pl.add_title('Point Cloud of 3D Surface')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(surf, color=True, show_edges=True)
| >>> _ = pl.add_title('Reconstructed Surface')
| >>> pl.show()
|
| See :ref:`surface_reconstruction_example` for more examples
| using this filter.
|
| remove_points(self, remove, mode='any', keep_scalars: 'bool' = True, inplace: 'bool' = False)
| Rebuild a mesh by removing points.
|
| Only valid for all-triangle meshes.
|
| Parameters
| ----------
| remove : sequence[bool | int]
| If remove is a bool array, points that are ``True`` will
| be removed. Otherwise, it is treated as a list of
| indices.
|
| mode : str, default: "any"
| When ``'all'``, only faces containing all points flagged
| for removal will be removed.
|
| keep_scalars : bool, default: True
| When ``True``, point and cell scalars will be passed on to
| the new mesh.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PolyData
| Mesh without the points flagged for removal.
|
| numpy.ndarray
| Indices of new points relative to the original mesh.
|
| Examples
| --------
| Remove the first 100 points from a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> reduced_sphere, ridx = sphere.remove_points(range(100, 250))
| >>> reduced_sphere.plot(show_edges=True, line_width=3)
|
| remove_unused_points(self: '_PolyDataType', *, inplace: 'bool' = False) -> '_PolyDataType'
| Remove points which are not used by any cells.
|
| This filter is similar to :meth:`clean` but does `not` merge points or convert cells.
| The point order is also unchanged by this filter.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy is returned.
|
| See Also
| --------
| pyvista.UnstructuredGridFilters.remove_unused_points
|
| Returns
| -------
| PolyData
| Mesh with unused points removed.
|
| Examples
| --------
| Create :class:`~pyvista.PolyData` with three points. The first two points are coincident
| and associated with :attr:`~pyvista.CellType.VERTEX` cells, and the third point is
| "unused" and not associated with any cells.
|
| >>> import pyvista as pv
| >>> points = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]
| >>> faces = [1, 0, 1, 1]
| >>> poly = pv.PolyData(points, faces)
| >>> poly
| PolyData (...)
| N Cells: 2
| N Points: 3
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 1.000e+00
| N Arrays: 0
|
| Since the third point is unused, we can remove it. Note that coincident points are `not`
| merged by this filter, so the two vertex points are kept as-is.
|
| >>> poly = poly.remove_unused_points()
| >>> poly
| PolyData (...)
| N Cells: 2
| N Points: 2
| N Strips: 0
| X Bounds: 0.000e+00, 0.000e+00
| Y Bounds: 0.000e+00, 0.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| N Arrays: 0
|
| ribbon(self, width=None, scalars=None, angle=0.0, factor=2.0, normal=None, tcoords: 'bool | str' = False, preference='points', progress_bar: 'bool' = False)
| Create a ribbon of the lines in this dataset.
|
| .. note::
| If there are no lines in the input dataset, then the output
| will be an empty :class:`pyvista.PolyData` mesh.
|
| Parameters
| ----------
| width : float, optional
| Set the "half" width of the ribbon. If the width is
| allowed to vary, this is the minimum width. The default is
| 10% the length.
|
| scalars : str, optional
| String name of the scalars array to use to vary the ribbon
| width. This is only used if a scalars array is specified.
|
| angle : float, optional
| Angle in degrees of the offset angle of the ribbon from
| the line normal. The default is 0.0.
|
| factor : float, optional
| Set the maximum ribbon width in terms of a multiple of the
| minimum width. The default is 2.0.
|
| normal : sequence[float], optional
| Normal to use as default.
|
| tcoords : bool, str, optional
| If ``True``, generate texture coordinates along the
| ribbon. This can also be specified to generate the texture
| coordinates with either ``'length'`` or ``'normalized'``.
|
| preference : str, optional
| The field preference when searching for the scalars array by
| name.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Ribbon mesh. Empty if there are no lines in the input dataset.
|
| Examples
| --------
| Convert a line to a ribbon and plot it.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> n = 1000
| >>> theta = np.linspace(-10 * np.pi, 10 * np.pi, n)
| >>> z = np.linspace(-2, 2, n)
| >>> r = z**2 + 1
| >>> x = r * np.sin(theta)
| >>> y = r * np.cos(theta)
| >>> points = np.column_stack((x, y, z))
| >>> pdata = pv.PolyData(points)
| >>> pdata.lines = np.hstack((n, range(n)))
| >>> pdata['distance'] = range(n)
| >>> ribbon = pdata.ribbon(width=0.2)
| >>> ribbon.plot(show_scalar_bar=False)
|
| ruled_surface(self, *, resolution: 'VectorLike[int] | None' = None, progress_bar: 'bool' = False)
| Create a ruled surface from a polyline.
|
| .. versionadded:: 0.45.0
|
| This filter is a filter that generates a surface from
| a set of lines. The lines are assumed to be "parallel"
| in the sense that they do not intersect and remain
| somewhat close to one another. A surface is generated
| by connecting the points defining each pair of lines
| with straight lines. This creates a strip for each pair
| of lines (i.e., a triangulation is created from two
| generating lines). The filter can handle an arbitrary
| number of lines, with lines i and i+1 assumed
| connected. Note that there are several different
| approaches for creating the ruled surface, the method
| for creating the surface can either use the input points
| or resample from the polylines (using a user-specified
| resolution).
|
| This filter implements :vtk:`vtkRuledSurfaceFilter`.
|
| Parameters
| ----------
| resolution : int, default: (1, 1)
| Set the number of points in the output polyline.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Ruled surface.
|
| Examples
| --------
| Create a ruled surface from a polyline.
|
| >>> import pyvista as pv
| >>> pl = pv.Plotter()
| >>> poly = pv.PolyData(
| ... [[0, 0, 1], [1, 0, 0], [0, 1, 0], [1, 1, 1]],
| ... lines=[[2, 0, 1], [2, 2, 3]],
| ... force_float=False,
| ... )
| >>> surface = poly.ruled_surface(resolution=(21, 21))
| >>> _ = pl.add_mesh(surface, show_edges=True)
| >>> pl.show()
|
| smooth(self, n_iter=20, relaxation_factor=0.01, convergence=0.0, edge_angle=15, feature_angle=45, boundary_smoothing: 'bool' = True, feature_smoothing: 'bool' = False, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Adjust point coordinates using Laplacian smoothing.
|
| The effect is to "relax" the mesh, making the cells better shaped and
| the vertices more evenly distributed.
|
| Parameters
| ----------
| n_iter : int, default: 20
| Number of iterations for Laplacian smoothing.
|
| relaxation_factor : float, default: 0.01
| Relaxation factor controls the amount of displacement in a single
| iteration. Generally a lower relaxation factor and higher number of
| iterations is numerically more stable.
|
| convergence : float, default: 0.0
| Convergence criterion for the iteration process. Smaller numbers
| result in more smoothing iterations. Range from (0 to 1).
|
| edge_angle : float, default: 15
| Edge angle to control smoothing along edges (either interior or boundary).
|
| feature_angle : float, default: 45
| Feature angle for sharp edge identification.
|
| boundary_smoothing : bool, default: True
| Flag to control smoothing of boundary edges. When ``True``,
| boundary edges remain fixed.
|
| feature_smoothing : bool, default: False
| Flag to control smoothing of feature edges. When ``True``,
| boundary edges remain fixed as defined by ``feature_angle`` and
| ``edge_angle``.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Smoothed mesh.
|
| Examples
| --------
| Smooth the edges of an all triangular cube
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(5)
| >>> smooth_cube = cube.smooth(n_iter=1000, feature_smoothing=False)
| >>> n_edge_cells = cube.extract_feature_edges().n_cells
| >>> n_smooth_cells = smooth_cube.extract_feature_edges().n_cells
| >>> f'Sharp Edges on Cube: {n_edge_cells}'
| 'Sharp Edges on Cube: 384'
| >>> f'Sharp Edges on Smooth Cube: {n_smooth_cells}'
| 'Sharp Edges on Smooth Cube: 12'
| >>> smooth_cube.plot()
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| smooth_taubin(self, n_iter=20, pass_band=0.1, edge_angle=15.0, feature_angle=45.0, boundary_smoothing: 'bool' = True, feature_smoothing: 'bool' = False, non_manifold_smoothing: 'bool' = False, normalize_coordinates: 'bool' = False, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Smooth a PolyData DataSet with Taubin smoothing.
|
| This filter allows you to smooth the mesh as in the Laplacian smoothing
| implementation in :func:`smooth() <PolyDataFilters.smooth>`. However,
| unlike Laplacian smoothing the surface does not "shrink" since this
| filter relies on an alternative approach to smoothing. This filter is
| more akin to a low pass filter where undesirable high frequency features
| are removed.
|
| This PyVista filter uses the VTK :vtk:`vtkWindowedSincPolyDataFilter`
| filter.
|
| Parameters
| ----------
| n_iter : int, default: 20
| This is the degree of the polynomial used to approximate the
| windowed sync function. This is generally much less than the number
| needed by :func:`smooth() <PolyDataFilters.smooth>`.
|
| pass_band : float, default: 0.1
| The passband value for the windowed sinc filter. This should be
| between 0 and 2, where lower values cause more smoothing.
|
| edge_angle : float, default: 15.0
| Edge angle to control smoothing along edges (either interior or
| boundary).
|
| feature_angle : float, default: 45.0
| Feature angle for sharp edge identification.
|
| boundary_smoothing : bool, default: True
| Flag to control smoothing of boundary edges. When ``True``,
| boundary edges remain fixed.
|
| feature_smoothing : bool, default: False
| Flag to control smoothing of feature edges. When ``True``,
| boundary edges remain fixed as defined by ``feature_angle`` and
| ``edge_angle``.
|
| non_manifold_smoothing : bool, default: False
| Smooth non-manifold points.
|
| normalize_coordinates : bool, default: False
| Flag to control coordinate normalization. To improve the
| numerical stability of the solution and minimize the scaling of the
| translation effects, the algorithm can translate and scale the
| position coordinates to within the unit cube ``[-1, 1]``, perform the
| smoothing, and translate and scale the position coordinates back to
| the original coordinate frame.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Smoothed mesh.
|
| Notes
| -----
| For maximum performance, do not enable ``feature_smoothing`` or
| ``boundary_smoothing``. ``feature_smoothing`` is especially expensive.
|
| References
| ----------
| See `Optimal Surface Smoothing as Filter Design
| <https://dl.acm.org/doi/pdf/10.1145/218380.218473>`_ for details
| regarding the implementation of Taubin smoothing.
|
| Examples
| --------
| Smooth the example bone mesh. Here, it's necessary to subdivide the
| mesh to increase the number of faces as the original mesh is so coarse.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_foot_bones().subdivide(2)
| >>> smoothed_mesh = mesh.smooth_taubin()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_text('Original Mesh')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(smoothed_mesh)
| >>> _ = pl.add_text('Smoothed Mesh')
| >>> pl.show()
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| strip(self, join: 'bool' = False, max_length=1000, pass_cell_data: 'bool' = False, pass_cell_ids: 'bool' = False, pass_point_ids: 'bool' = False, progress_bar: 'bool' = False)
| Strip poly data cells.
|
| Generates triangle strips and/or poly-lines from input
| polygons, triangle strips, and lines.
|
| Polygons are assembled into triangle strips only if they are
| triangles; other types of polygons are passed through to the
| output and not stripped. (Use ``triangulate`` filter to
| triangulate non-triangular polygons prior to running this
| filter if you need to strip all the data.) The filter will
| pass through (to the output) vertices if they are present in
| the input polydata.
|
| Also note that if triangle strips or polylines are defined in
| the input they are passed through and not joined nor
| extended. (If you wish to strip these use ``triangulate``
| filter to fragment the input into triangles and lines prior to
| running this filter.)
|
| This filter implements :vtk:`vtkStripper`.
|
| Parameters
| ----------
| join : bool, default: False
| If ``True``, the output polygonal segments will be joined
| if they are contiguous. This is useful after slicing a
| surface.
|
| max_length : int, default: 1000
| Specify the maximum number of triangles in a triangle
| strip, and/or the maximum number of lines in a poly-line.
|
| pass_cell_data : bool, default: False
| Enable/Disable passing of the CellData in the input to the
| output as FieldData. Note the field data is transformed.
|
| pass_cell_ids : bool, default: False
| If ``True``, the output polygonal dataset will have a
| celldata array that holds the cell index of the original
| 3D cell that produced each output cell. This is useful for
| picking. The default is ``False`` to conserve memory.
|
| pass_point_ids : bool, default: False
| If ``True``, the output polygonal dataset will have a
| pointdata array that holds the point index of the original
| vertex that produced each output vertex. This is useful
| for picking. The default is ``False`` to conserve memory.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Stripped mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> slc = mesh.slice(normal='z', origin=(0, 0, -10))
| >>> stripped = slc.strip()
| >>> stripped.n_cells
| 1
| >>> stripped.plot(show_edges=True, line_width=3)
|
| subdivide(self, nsub, subfilter='linear', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Increase the number of triangles in a single, connected triangular mesh.
|
| Uses one of the following vtk subdivision filters to subdivide a mesh:
|
| * :vtk:`vtkButterflySubdivisionFilter`
| * :vtk:`vtkLoopSubdivisionFilter`
| * :vtk:`vtkLinearSubdivisionFilter`
|
| Linear subdivision results in the fastest mesh subdivision,
| but it does not smooth mesh edges, but rather splits each
| triangle into 4 smaller triangles.
|
| Butterfly and loop subdivision perform smoothing when
| dividing, and may introduce artifacts into the mesh when
| dividing.
|
| .. note::
| Subdivision filter sometimes fails for multiple part
| meshes. The input should be one connected mesh.
|
| Parameters
| ----------
| nsub : int
| Number of subdivisions. Each subdivision creates 4 new
| triangles, so the number of resulting triangles is
| ``nface*4**nsub`` where ``nface`` is the current number of
| faces.
|
| subfilter : str, default: "linear"
| Can be one of the following:
|
| * ``'butterfly'``
| * ``'loop'``
| * ``'linear'``
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Subdivided mesh.
|
| Examples
| --------
| First, create an example coarse sphere mesh and plot it.
|
| >>> from pyvista import examples
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(phi_resolution=10, theta_resolution=10)
| >>> mesh.plot(show_edges=True, line_width=3)
|
| Subdivide the sphere mesh using linear subdivision.
|
| >>> submesh = mesh.subdivide(1, 'linear')
| >>> submesh.plot(show_edges=True, line_width=3)
|
| Subdivide the sphere mesh using loop subdivision.
|
| >>> submesh = mesh.subdivide(1, 'loop')
| >>> submesh.plot(show_edges=True, line_width=3)
|
| Subdivide the sphere mesh using butterfly subdivision.
|
| >>> submesh = mesh.subdivide(1, 'butterfly')
| >>> submesh.plot(show_edges=True, line_width=3)
|
| subdivide_adaptive(self, max_edge_len=None, max_tri_area=None, max_n_tris=None, max_n_passes=None, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Increase the number of triangles in a triangular mesh based on edge and/or area metrics.
|
| This filter uses a simple case-based, multi-pass approach to
| repeatedly subdivide the input triangle mesh to meet the area
| and/or edge length criteria. New points may be inserted only
| on edges; depending on the number of edges to be subdivided a
| different number of triangles are inserted ranging from two
| (i.e., two triangles replace the original one) to four.
|
| Point and cell data is treated as follows: The cell data from
| a parent triangle is assigned to its subdivided
| children. Point data is interpolated along edges as the edges
| are subdivided.
|
| This filter retains mesh watertightness if the mesh was
| originally watertight; and the area and max triangles criteria
| are not used.
|
| Parameters
| ----------
| max_edge_len : float, optional
| The maximum edge length that a triangle may have. Edges
| longer than this value are split in half and the
| associated triangles are modified accordingly.
|
| max_tri_area : float, optional
| The maximum area that a triangle may have. Triangles
| larger than this value are subdivided to meet this
| threshold. Note that if this criterion is used it may
| produce non-watertight meshes as a result.
|
| max_n_tris : int, optional
| The maximum number of triangles that can be created. If
| the limit is hit, it may result in premature termination
| of the algorithm and the results may be less than
| satisfactory (for example non-watertight meshes may be
| created). By default, the limit is set to a very large
| number (i.e., no effective limit).
|
| max_n_passes : int, optional
| The maximum number of passes (i.e., levels of
| subdivision). If the limit is hit, then the subdivision
| process stops and additional passes (needed to meet other
| criteria) are aborted. The default limit is set to a very
| large number (i.e., no effective limit).
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Subdivided mesh.
|
| Examples
| --------
| First, load the example airplane mesh and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.PolyData(examples.planefile)
| >>> mesh.plot(show_edges=True, line_width=3)
|
| Subdivide the mesh
|
| >>> submesh = mesh.subdivide_adaptive(max_n_passes=2)
| >>> submesh.plot(show_edges=True)
|
| triangulate(self, *, pass_verts: 'bool' = False, pass_lines: 'bool' = False, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| pass_verts : bool, default: False
| Whether vertices cells are passed to the output PolyData.
|
| .. versionadded:: 0.45.0
|
| pass_lines : bool, default: False
| Whether lines cells are passed to the output PolyData.
|
| .. versionadded:: 0.45.0
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| triangulate_contours(self: '_PolyDataType', display_errors: 'bool' = False, progress_bar: 'bool' = False) -> '_PolyDataType'
| Triangulate and fill all 2D contours to create polygons.
|
| .. versionadded:: 0.44.0
|
| This filter will generate triangles to fill all of the 2D contours
| in its input. The input to the filter is a set of lines (not polylines)
| which when joined form loops. The contours may be concave, and may even
| contain holes i.e. a contour may contain an internal contour that is
| wound in the opposite direction (as compared to the outer polygon
| normal) to indicate that it is a hole.
|
| .. note::
|
| This filter will assume that the input polygons lie in the same
| plane and will not perform any projection or transformation of the
| input data. You may need to project your data to a plane before
| using this filter.
|
| .. warning::
|
| The triangulation of is done in O(n) time for simple convex inputs,
| but for non-convex inputs the worst-case time is O(n^2*m^2) where n
| is the number of points and m is the number of holes. The best
| triangulation algorithms, in contrast, are O(n log n). The
| resulting triangles may be quite narrow, the algorithm does not
| attempt to produce high-quality triangles.
|
| Parameters
| ----------
| display_errors : bool, default: False
| Generate errors when the triangulation fails. Note that
| triangulation failures are often minor, because they involve tiny
| triangles that are too small to see.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Raises
| ------
| RuntimeError
| If the mesh does not contain lines.
|
| Returns
| -------
| pyvista.PolyData
| Triangulated mesh with the filled contours.
|
| Examples
| --------
| Create banded contour and fill.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.download_st_helens()
| >>> contours = image.contour([1302.3334, 1922.6666])
| >>> filled = contours.triangulate_contours()
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(image, show_scalar_bar=False)
| >>> _ = pl.add_mesh(contours, color='black')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(contours, color='black')
| >>> _ = pl.add_mesh(filled, color='red')
| >>> pl.link_views()
| >>> pl.view_xy()
| >>> pl.show()
|
| tube(self, radius=None, scalars=None, capping: 'bool' = True, n_sides=20, radius_factor=10.0, absolute: 'bool' = False, preference='point', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Generate a tube around each input line.
|
| The radius of the tube can be set to linearly vary with a
| scalar value.
|
| Parameters
| ----------
| radius : float, optional
| Minimum tube radius (minimum because the tube radius may
| vary).
|
| scalars : str, optional
| Scalars array by which the radius varies.
|
| capping : bool, default: True
| Turn on/off whether to cap the ends with polygons.
|
| n_sides : int, default: 20
| Set the number of sides for the tube. Minimum of 3.
|
| radius_factor : float, default: 10.0
| Maximum tube radius in terms of a multiple of the minimum
| radius.
|
| absolute : bool, default: False
| Vary the radius with values from scalars in absolute units.
|
| preference : str, default: 'point'
| The field preference when searching for the scalars array by
| name.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Tube-filtered mesh.
|
| Examples
| --------
| Convert a single line to a tube.
|
| >>> import pyvista as pv
| >>> line = pv.Line()
| >>> tube = line.tube(radius=0.02)
| >>> f'Line Cells: {line.n_cells}'
| 'Line Cells: 1'
| >>> f'Tube Cells: {tube.n_cells}'
| 'Tube Cells: 22'
| >>> tube.plot(color='lightblue')
|
| See :ref:`create_spline_example` for more examples using this filter.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
class RectilinearGridFilters(builtins.object)
| RectilinearGridFilters(*args, **kwargs)
|
| An internal class to manage filters/algorithms for rectilinear grid datasets.
|
| Methods defined here:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| to_tetrahedra(self, tetra_per_cell: 'int' = 5, mixed: 'str | Sequence[int] | bool' = False, pass_cell_ids: 'bool' = True, pass_data: 'bool' = True, progress_bar: 'bool' = False)
| Create a tetrahedral mesh structured grid.
|
| Parameters
| ----------
| tetra_per_cell : int, default: 5
| The number of tetrahedrons to divide each cell into. Can be
| either ``5``, ``6``, or ``12``. If ``mixed=True``, this value is
| overridden.
|
| mixed : str, bool, sequence, default: False
| When set, subdivides some cells into 5 and some cells into 12. Set
| to ``True`` to use the active cell scalars of the
| :class:`pyvista.RectilinearGrid` to be either 5 or 12 to
| determining the number of tetrahedra to generate per cell.
|
| When a sequence, uses these values to subdivide the cells. When a
| string uses a cell array rather than the active array to determine
| the number of tetrahedra to generate per cell.
|
| pass_cell_ids : bool, default: True
| Set to ``True`` to make the tetrahedra have scalar data indicating
| which cell they came from in the original
| :class:`pyvista.RectilinearGrid`. The name of this array is
| ``'vtkOriginalCellIds'`` within the ``cell_data``.
|
| pass_data : bool, default: True
| Set to ``True`` to make the tetrahedra mesh have the cell data from
| the original :class:`pyvista.RectilinearGrid`. This uses
| ``pass_cell_ids=True`` internally. If ``True``, ``pass_cell_ids``
| will also be set to ``True``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the tetrahedral cells.
|
| Examples
| --------
| Divide a rectangular grid into tetrahedrons. Each cell contains by
| default 5 tetrahedrons.
|
| First, create and plot the grid.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 2)
| >>> yrng = np.linspace(0, 1, 2)
| >>> zrng = np.linspace(0, 2, 3)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> grid.plot()
|
| Now, generate the tetrahedra plot in the exploded view of the cell.
|
| >>> tet_grid = grid.to_tetrahedra()
| >>> tet_grid.explode(factor=0.5).plot(show_edges=True)
|
| Take the same grid but divide the first cell into 5 cells and the other
| cell into 12 tetrahedrons per cell.
|
| >>> tet_grid = grid.to_tetrahedra(mixed=[5, 12])
| >>> tet_grid.explode(factor=0.5).plot(show_edges=True)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
class StructuredGridFilters(pyvista.core.filters.data_set.DataSetFilters)
| StructuredGridFilters(*args, **kwargs)
|
| An internal class to manage filters/algorithms for structured grid datasets.
|
| Method resolution order:
| StructuredGridFilters
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| builtins.object
|
| Methods defined here:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| concatenate(self, other, axis, tolerance=0.0)
| Concatenate a structured grid to this grid.
|
| Joins structured grids into a single structured grid. Grids
| must be of compatible dimension, and must be coincident along
| the seam. Grids must have the same point and cell data. Field
| data is ignored.
|
| Parameters
| ----------
| other : pyvista.StructuredGrid
| Structured grid to concatenate.
|
| axis : int
| Axis along which to concatenate.
|
| tolerance : float, default: 0.0
| Tolerance for point coincidence along joining seam.
|
| Returns
| -------
| pyvista.StructuredGrid
| Concatenated grid.
|
| Examples
| --------
| Split a grid in half and join them.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_structured()
| >>> voi_1 = grid.extract_subset([0, 80, 0, 40, 0, 1], boundary=True)
| >>> voi_2 = grid.extract_subset([0, 80, 40, 80, 0, 1], boundary=True)
| >>> joined = voi_1.concatenate(voi_2, axis=1)
| >>> f'{grid.dimensions} same as {joined.dimensions}'
| '(80, 80, 1) same as (80, 80, 1)'
|
| extract_subset(self, voi, rate=(1, 1, 1), boundary: 'bool' = False)
| Select piece (e.g., volume of interest).
|
| To use this filter set the VOI ivar which are i-j-k min/max
| indices that specify a rectangular region in the data. (Note
| that these are 0-offset.) You can also specify a sampling rate
| to subsample the data.
|
| Typical applications of this filter are to extract a slice
| from a volume for image processing, subsampling large volumes
| to reduce data size, or extracting regions of a volume with
| interesting data.
|
| Parameters
| ----------
| voi : sequence[int]
| Length 6 iterable of ints: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| These bounds specify the volume of interest in i-j-k min/max
| indices.
|
| rate : sequence[int], default: (1, 1, 1)
| Length 3 iterable of ints: ``(xrate, yrate, zrate)``.
|
| boundary : bool, default: False
| Control whether to enforce that the "boundary" of the grid
| is output in the subsampling process. (This only has
| effect when the rate in any direction is not equal to
| 1). When this is on, the subsampling will always include
| the boundary of the grid even if the sample rate is
| not an even multiple of the grid dimensions.
|
| Returns
| -------
| pyvista.StructuredGrid
| StructuredGrid with extracted subset.
|
| Examples
| --------
| Split a grid in half.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_structured()
| >>> voi_1 = grid.extract_subset([0, 80, 0, 40, 0, 1], boundary=True)
| >>> voi_2 = grid.extract_subset([0, 80, 40, 80, 0, 1], boundary=True)
|
| For fun, add the two grids back together and show they are
| identical to the original grid.
|
| >>> joined = voi_1.concatenate(voi_2, axis=1)
| >>> assert np.allclose(grid.points, joined.points)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
class UnstructuredGridFilters(pyvista.core.filters.data_set.DataSetFilters)
| UnstructuredGridFilters(*args, **kwargs)
|
| An internal class to manage filters/algorithms for unstructured grid datasets.
|
| Method resolution order:
| UnstructuredGridFilters
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| builtins.object
|
| Methods defined here:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| clean(self, tolerance=0, remove_unused_points: 'bool' = True, produce_merge_map: 'bool' = True, average_point_data: 'bool' = True, merging_array_name=None, progress_bar: 'bool' = False)
| Merge duplicate points and remove unused points in an UnstructuredGrid.
|
| This filter, merging coincident points as defined by a merging
| tolerance and optionally removes unused points. The filter does not
| modify the topology of the input dataset, nor change the types of
| cells. It may however, renumber the cell connectivity ids.
|
| This filter implements :vtk:`vtkStaticCleanUnstructuredGrid`.
|
| Parameters
| ----------
| tolerance : float, default: 0.0
| The absolute point merging tolerance.
|
| remove_unused_points : bool, default: True
| Indicate whether points unused by any cell are removed from the
| output. Note that when this is off, the filter can successfully
| process datasets with no cells (and just points). If on in this
| case, and there are no cells, the output will be empty.
|
| produce_merge_map : bool, default: False
| Indicate whether a merge map should be produced on output.
| The merge map, if requested, maps each input point to its
| output point id, or provides a value of -1 if the input point
| is not used in the output. The merge map is associated with
| the filter's output field data and is named ``"PointMergeMap"``.
|
| average_point_data : bool, default: True
| Indicate whether point coordinates and point data of merged points
| are averaged. When ``True``, the data coordinates and attribute
| values of all merged points are averaged. When ``False``, the point
| coordinate and data of the single remaining merged point is
| retained.
|
| merging_array_name : str, optional
| If a ``merging_array_name`` is specified and exists in the
| ``point_data``, then point merging will switch into a mode where
| merged points must be both geometrically coincident and have
| matching point data. When set, ``tolerance`` has no effect.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Cleaned unstructured grid.
|
| See Also
| --------
| remove_unused_points
| Strictly remove unused points `without` merging points.
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Demonstrate cleaning an UnstructuredGrid and show how it can be used to
| average the point data across merged points.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hexbeam = examples.load_hexbeam()
| >>> hexbeam_shifted = hexbeam.translate([1, 0, 0])
| >>> hexbeam.point_data['data'] = [0] * hexbeam.n_points
| >>> hexbeam_shifted.point_data['data'] = [1] * hexbeam.n_points
| >>> merged = hexbeam.merge(hexbeam_shifted, merge_points=False)
| >>> cleaned = merged.clean(average_point_data=True)
| >>> cleaned.n_points < merged.n_points
| True
|
| Show how point averaging using the ``clean`` method with
| ``average_point_data=True`` results in averaged point data for merged
| points.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(merged, scalars='data', show_scalar_bar=False)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cleaned, scalars='data')
| >>> pl.show()
|
| delaunay_2d(self, tol=1e-05, alpha=0.0, offset=1.0, bound: 'bool' = False, inplace: 'bool' = False, edge_source=None, progress_bar: 'bool' = False) from pyvista.core.filters.poly_data.PolyDataFilters
| Apply a 2D Delaunay filter along the best fitting plane.
|
| This filter can be used to generate a 2d surface from a set of
| points on a plane. If you want to create a surface from a
| point cloud, see :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| tol : float, default: 1e-05
| Specify a tolerance to control discarding of closely
| spaced points. This tolerance is specified as a fraction
| of the diagonal length of the bounding box of the points.
|
| alpha : float, default: 0.0
| Specify alpha (or distance) value to control output of
| this filter. For a non-zero alpha value, only edges or
| triangles contained within a sphere centered at mesh
| vertices will be output. Otherwise, only triangles will be
| output.
|
| offset : float, default: 1.0
| Specify a multiplier to control the size of the initial,
| bounding Delaunay triangulation.
|
| bound : bool, default: False
| Boolean controls whether bounding triangulation points
| and associated triangles are included in the
| output. These are introduced as an initial triangulation
| to begin the triangulation process. This feature is nice
| for debugging output.
|
| inplace : bool, default: False
| If ``True``, overwrite this mesh with the triangulated
| mesh.
|
| edge_source : pyvista.PolyData, optional
| Specify the source object used to specify constrained
| edges and loops. If set, and lines/polygons are defined, a
| constrained triangulation is created. The lines/polygons
| are assumed to reference points in the input point set
| (i.e. point ids are identical in the input and
| source).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh from the 2D delaunay filter.
|
| Examples
| --------
| First, generate 30 points on circle and plot them.
|
| >>> import pyvista as pv
| >>> points = pv.Polygon(n_sides=30).points
| >>> circle = pv.PolyData(points)
| >>> circle.plot(show_edges=True, point_size=15)
|
| Use :func:`delaunay_2d` to fill the interior of the circle.
|
| >>> filled_circle = circle.delaunay_2d()
| >>> filled_circle.plot(show_edges=True, line_width=5)
|
| Use the ``edge_source`` parameter to create a constrained delaunay
| triangulation and plot it.
|
| >>> squar = pv.Polygon(n_sides=4, radius=8, fill=False)
| >>> squar = squar.rotate_z(45, inplace=False)
| >>> circ0 = pv.Polygon(center=(2, 3, 0), n_sides=30, radius=1)
| >>> circ1 = pv.Polygon(center=(-2, -3, 0), n_sides=30, radius=1)
| >>> comb = circ0.append_polydata(circ1, squar)
| >>> tess = comb.delaunay_2d(edge_source=comb)
| >>> tess.plot(cpos='xy', show_edges=True)
|
| See :ref:`create_tri_surface_example` for more examples using this filter.
|
| reconstruct_surface(self, nbr_sz=None, sample_spacing=None, progress_bar: 'bool' = False) from pyvista.core.filters.poly_data.PolyDataFilters
| Reconstruct a surface from the points in this dataset.
|
| This filter takes a list of points assumed to lie on the
| surface of a solid 3D object. A signed measure of the distance
| to the surface is computed and sampled on a regular grid. The
| grid can then be contoured at zero to extract the surface. The
| default values for neighborhood size and sample spacing should
| give reasonable results for most uses but can be set if
| desired.
|
| This is helpful when generating surfaces from point clouds and
| is more reliable than :func:`DataSetFilters.delaunay_3d`.
|
| Parameters
| ----------
| nbr_sz : int, optional
| Specify the number of neighbors each point has, used for
| estimating the local surface orientation.
|
| The default value of 20 should be fine for most
| applications, higher values can be specified if the spread
| of points is uneven. Values as low as 10 may yield
| adequate results for some surfaces. Higher values cause
| the algorithm to take longer and will cause
| errors on sharp boundaries.
|
| sample_spacing : float, optional
| The spacing of the 3D sampling grid. If not set, a
| reasonable guess will be made.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Reconstructed surface.
|
| Examples
| --------
| Create a point cloud out of a sphere and reconstruct a surface
| from it.
|
| >>> import pyvista as pv
| >>> points = pv.wrap(pv.Sphere().points)
| >>> surf = points.reconstruct_surface()
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(points)
| >>> _ = pl.add_title('Point Cloud of 3D Surface')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(surf, color=True, show_edges=True)
| >>> _ = pl.add_title('Reconstructed Surface')
| >>> pl.show()
|
| See :ref:`surface_reconstruction_example` for more examples
| using this filter.
|
| remove_unused_points(self: '_UnstructuredGridType', *, inplace: 'bool' = False) -> '_UnstructuredGridType'
| Remove points which are not used by any cells.
|
| Unlike :meth:`clean`, this filter does `not` merge points.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy is returned.
|
| See Also
| --------
| pyvista.PolyDataFilters.remove_unused_points
|
| Returns
| -------
| UnstructuredGrid
| Mesh with unused points removed.
|
| Examples
| --------
| Create :class:`~pyvista.UnstructuredGrid` with three points. The first two points are
| coincident and associated with :attr:`~pyvista.CellType.VERTEX` cells, and the third point
| is "unused" and not associated with any cells.
|
| >>> import pyvista as pv
| >>> cells = [1, 0, 1, 1]
| >>> celltypes = [pv.CellType.VERTEX, pv.CellType.VERTEX]
| >>> points = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]
| >>> grid = pv.UnstructuredGrid(cells, celltypes, points)
| >>> grid
| UnstructuredGrid (...)
| N Cells: 2
| N Points: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 1.000e+00
| N Arrays: 0
|
| Since the third point is unused, we can remove it. Note that coincident points are `not`
| merged by this filter, so the two vertex points are kept as-is.
|
| >>> grid = grid.remove_unused_points()
| >>> grid
| UnstructuredGrid (...)
| N Cells: 2
| N Points: 2
| X Bounds: 0.000e+00, 0.000e+00
| Y Bounds: 0.000e+00, 0.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| N Arrays: 0
|
| subdivide_tetra(self)
| Subdivide each tetrahedron into twelve tetrahedrons.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the subdivided tetrahedrons.
|
| Examples
| --------
| First, load a sample tetrahedral UnstructuredGrid and plot it.
|
| >>> from pyvista import examples
| >>> grid = examples.load_tetbeam()
| >>> grid.plot(show_edges=True, line_width=2)
|
| Now, subdivide and plot.
|
| >>> subdivided = grid.subdivide_tetra()
| >>> subdivided.plot(show_edges=True, line_width=2)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
FUNCTIONS
_get_output(algorithm: '_vtk.vtkAlgorithm', *, iport=0, iconnection=0, oport=0, active_scalars=None, active_scalars_field='point')
Get the algorithm's output and copy input's pyvista meta info.
_update_alg(alg: '_vtk.vtkAlgorithm', *, progress_bar: 'bool' = False, message='') -> 'None'
Update an algorithm with or without a progress bar.
DATA
__all__ = ['CompositeFilters', 'DataObjectFilters', 'DataSetFilters', ...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\filters\__init__.py
pyvista.fit_line_to_points
Python Library Documentation: function fit_line_to_points in module pyvista.core.utilities.points
fit_line_to_points(points: 'MatrixLike[float]', *, resolution: 'int' = 1, init_direction: 'VectorLike[float] | None' = None, return_meta: 'bool' = False) -> 'PolyData | tuple[PolyData, float, NumpyArray[float]]'
Fit a line to points using its :func:`principal_axes`.
The line is automatically sized and oriented to fit the extents of
the points.
.. versionadded:: 0.45.0
Parameters
----------
points : MatrixLike[float]
Size ``[N x 3]`` array of points to fit a line through.
resolution : int, default: 1
Number of pieces to divide the line into.
init_direction : VectorLike[float], optional
Flip the direction of the line's points such that it best aligns with this
vector. Can be a vector or string specifying the axis by name (e.g. ``'x'``
or ``'-x'``, etc.).
return_meta : bool, default: False
If ``True``, also returns the length (magnitude) and direction of the line.
See Also
--------
fit_plane_to_points
Fit a plane using the first two principal axes of the points.
principal_axes
Compute axes vectors which best fit a set of points.
Returns
-------
pyvista.PolyData
Line mesh.
float
Line length if ``return_meta=True``.
numpy.ndarray
Line direction (unit vector) if ``return_meta=True``.
Examples
--------
Download a point cloud. The points trace a path along topographical surface.
>>> import pyvista as pv
>>> from pyvista import examples
>>> mesh = examples.download_gpr_path()
Fit a line to the points and plot the result. The line of best fit is colored red.
>>> line = pv.fit_line_to_points(mesh.points)
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(mesh, color='black', line_width=10)
>>> _ = pl.add_mesh(line, color='red', line_width=5)
>>> pl.show()
Fit a line to a mesh and return the metadata.
>>> mesh = examples.download_human()
>>> line, length, direction = pv.fit_line_to_points(
... mesh.points, return_meta=True
... )
Show the length of the line.
>>> length
167.6145
Plot the line as an arrow to show its direction.
>>> arrow = pv.Arrow(
... start=line.points[0],
... direction=direction,
... scale=length,
... tip_length=0.2,
... tip_radius=0.04,
... shaft_radius=0.01,
... )
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(mesh, opacity=0.5)
>>> _ = pl.add_mesh(arrow, color='red')
>>> pl.show()
Set ``init_direction`` to the positive z-axis to flip the line's direction.
>>> mesh = examples.download_human()
>>> line, length, direction = pv.fit_line_to_points(
... mesh.points, init_direction='z', return_meta=True
... )
Plot the results again with an arrow.
>>> arrow = pv.Arrow(
... start=line.points[0],
... direction=direction,
... scale=length,
... tip_length=0.2,
... tip_radius=0.04,
... shaft_radius=0.01,
... )
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(mesh, opacity=0.5)
>>> _ = pl.add_mesh(arrow, color='red')
>>> pl.show()
pyvista.fit_plane_to_points
Python Library Documentation: function fit_plane_to_points in module pyvista.core.utilities.points
fit_plane_to_points(points: 'MatrixLike[float]', return_meta: 'bool' = False, resolution: 'int' = 10, init_normal: 'VectorLike[float] | None' = None) -> 'PolyData | tuple[PolyData, float, NumpyArray[float]]'
Fit a plane to points using its :func:`principal_axes`.
The plane is automatically sized and oriented to fit the extents of
the points.
.. versionchanged:: 0.42.0
The generated plane is now sized and oriented to match the points.
.. versionchanged:: 0.42.0
The center of the plane (returned if ``return_meta=True``) is now
computed as the center of the generated plane mesh. In previous
versions, the center of the input points was returned.
.. versionchanged:: 0.45.0
The internal method used for fitting the plane has changed. Previously, singular
value decomposition (SVD) was used, but eigenvectors are now used instead.
See warning below.
.. warning::
The sign of the plane's normal vector prior to version 0.45 may differ
from the latest version. This may impact methods which rely on the plane's
direction. Use ``init_normal`` to control the sign explicitly.
Parameters
----------
points : array_like[float]
Size ``[N x 3]`` sequence of points to fit a plane through.
return_meta : bool, default: False
If ``True``, also returns the center and normal of the
generated plane.
resolution : int, default: 10
Number of points on the plane mesh along its edges. Specify two numbers to
set the resolution along the plane's long and short edge (respectively) or
a single number to set both edges to have the same resolution.
.. versionadded:: 0.45.0
init_normal : VectorLike[float] | str, optional
Flip the normal of the plane such that it best aligns with this vector. Can be
a vector or string specifying the axis by name (e.g. ``'x'`` or ``'-x'``, etc.).
.. versionadded:: 0.45.0
Returns
-------
pyvista.PolyData
Plane mesh.
pyvista.pyvista_ndarray
Plane center if ``return_meta=True``.
pyvista.pyvista_ndarray
Plane normal if ``return_meta=True``.
See Also
--------
fit_line_to_points
Fit a line using the first principal axis of the points.
principal_axes
Compute axes vectors which best fit a set of points.
Examples
--------
Fit a plane to a random point cloud.
>>> import pyvista as pv
>>> import numpy as np
>>> from pyvista import examples
>>>
>>> rng = np.random.default_rng(seed=0)
>>> cloud = rng.random((10, 3))
>>> cloud[:, 2] *= 0.1
>>>
>>> plane = pv.fit_plane_to_points(cloud)
Plot the point cloud and fitted plane.
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(plane, style='wireframe', line_width=4)
>>> _ = pl.add_points(
... cloud,
... render_points_as_spheres=True,
... color='r',
... point_size=30,
... )
>>> pl.show()
Fit a plane to a mesh and return its metadata. Set the plane resolution to 1
so that the plane has no internal points or edges.
>>> mesh = examples.download_shark()
>>> plane, center, normal = pv.fit_plane_to_points(
... mesh.points, return_meta=True, resolution=1
... )
Plot the mesh and fitted plane.
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(plane, show_edges=True, opacity=0.25)
>>> _ = pl.add_mesh(mesh, color='gray')
>>> pl.camera_position = pv.CameraPosition(
... position=(-117, 76, 235),
... focal_point=(1.69, -1.38, 0),
... viewup=(0.189, 0.957, -0.22),
... )
>>> pl.show()
Use the metadata with :meth:`pyvista.DataObjectFilters.clip` to split the mesh into
two.
>>> first_half, second_half = mesh.clip(
... origin=center, normal=normal, return_clipped=True
... )
Plot the two halves of the clipped mesh.
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(first_half, color='red')
>>> _ = pl.add_mesh(second_half, color='blue')
>>> pl.camera_position = pv.CameraPosition(
... position=(-143, 43, 40),
... focal_point=(-8.7, -11, -14),
... viewup=(0.25, 0.92, -0.29),
... )
>>> pl.show()
Note that it is pointing in the positive z-direction.
>>> normal # doctest:+SKIP
pyvista_ndarray([0.0, 0.0, 1.0], dtype=float32)
Use ``init_normal`` to flip the sign and make it negative instead.
>>> _, _, normal = pv.fit_plane_to_points(
... mesh.points, return_meta=True, init_normal='-z'
... )
>>> normal # doctest:+SKIP
pyvista_ndarray([0.0, 0.0, -1.0], dtype=float32)
pyvista.formatting_html
Python Library Documentation: module pyvista.core.formatting_html in pyvista.core
NAME
pyvista.core.formatting_html - HTML representation for PyVista objects in Jupyter notebooks.
DESCRIPTION
Uses pure HTML/CSS with checkbox-driven expand/collapse. The only
JavaScript is a minimal ``navigator.clipboard.writeText`` call for
copy-to-clipboard buttons.
Works in Jupyter Notebook, JupyterLab, VS Code, Colab, and nbviewer.
FUNCTIONS
build_repr_html(obj_type: 'str', mesh_type: 'str', *, header_badges: 'Sequence[str]' = (), metadata: 'Sequence[tuple[str, list[tuple[str, str]], str]]' = (), sections: 'Sequence[str]' = (), text_repr: 'str' = '') -> 'str'
Assemble a complete HTML repr with header, metadata, sections, and fallback.
Parameters
----------
obj_type : str
Display name (e.g. ``'PolyData'``).
mesh_type : str
Key for mesh icon lookup (e.g. ``'PolyData'``).
header_badges : Sequence[str]
Labels shown as small badges in the header (e.g. memory size).
metadata : Sequence[tuple[str, list[tuple[str, str]], str]]
Always-visible key-value rows rendered between the header and
collapsible sections. Each entry is
``(row_label, [(key, val), ...], copy_text)``.
sections : Sequence[str]
List of collapsible-section HTML fragments.
text_repr : str
Plain-text fallback for non-HTML environments.
Returns
-------
str
Complete HTML string.
collapsible_section(header: 'str', *, inline_details: 'str' = '', details: 'str' = '', n_items: 'int | None' = None, enabled: 'bool' = True, collapsed: 'bool' = False) -> 'str'
Build an expand/collapse section using a hidden checkbox.
Parameters
----------
header : str
Section label (e.g. ``'Point Data:'``).
inline_details : str
Content shown when collapsed.
details : str
Content shown when expanded.
n_items : int, optional
Item count displayed in parentheses. A value of ``0``
disables the section.
enabled : bool
Whether the section is expandable.
collapsed : bool
Whether the section starts collapsed.
Returns
-------
str
HTML fragment for the section.
DATA
TYPE_CHECKING = False
__annotations__ = {'_MESH_TYPE_ICONS': 'dict[str, str]'}
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\formatting_html.py
pyvista.from_meshio
Python Library Documentation: function from_meshio in module pyvista.core.utilities.fileio
from_meshio(mesh: 'meshio.Mesh') -> 'UnstructuredGrid'
Convert a ``meshio`` mesh instance to a PyVista mesh.
Parameters
----------
mesh : meshio.Mesh
A mesh instance from the ``meshio`` library.
Returns
-------
pyvista.UnstructuredGrid
A PyVista unstructured grid representation of the input ``meshio`` mesh.
Raises
------
ImportError
If the appropriate version of ``meshio`` library is not found.
pyvista.from_trimesh
Python Library Documentation: function from_trimesh in module pyvista.core.utilities.fileio
from_trimesh(mesh: 'trimesh.Trimesh', *, pass_data: '_PassDataOptions' = True) -> 'PolyData'
Convert a Trimesh mesh to a PyVista mesh.
- ``vertex_attributes`` are stored as point data.
- ``face_attributes`` are stored as cell data.
- ``metadata`` is stored as field data: NumPy arrays are stored directly as field data
arrays, and any other metadata (e.g. strings or lists) is stored in the
:attr:`~pyvista.DataObject.user_dict`.
.. note::
No copies of point, cell, or data arrays are made. Use :meth:`~pyvista.DataObject.copy`
after converting to avoid any side effects.
.. versionadded:: 0.47
Parameters
----------
mesh : trimesh.Trimesh
Trimesh object to convert.
pass_data : bool | str | sequence[str], default: True
Pass point, cell, and/or field data from the Trimesh object. All data is passed by default.
Set this to ``'point'``, ``'cell'``, ``'field'`` or any combination thereof to only pass
specific fields.
See Also
--------
to_trimesh, from_meshio, :func:`~pyvista.wrap`
Examples
--------
See :ref:`wrap_trimesh_example` for examples.
pyvista.generate_plane
Python Library Documentation: function generate_plane in module pyvista.core.utilities.helpers
generate_plane(normal: 'VectorLike[float]', origin: 'VectorLike[float]')
Return a :vtk:`vtkPlane`.
Parameters
----------
normal : sequence[float]
Three item sequence representing the normal of the plane.
origin : sequence[float]
Three item sequence representing the origin of the plane.
Returns
-------
:vtk:`vtkPlane`
VTK plane.
pyvista.geometric_objects
Python Library Documentation: module pyvista.core.utilities.geometric_objects in pyvista.core.utilities
NAME
pyvista.core.utilities.geometric_objects - Provides an easy way of generating several geometric objects.
FUNCTIONS
Arrow(start: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0), tip_length: 'float' = 0.25, tip_radius: 'float' = 0.1, tip_resolution: 'int' = 20, shaft_radius: 'float' = 0.05, shaft_resolution: 'int' = 20, scale: "float | Literal['auto'] | None" = 1.0) -> 'PolyData'
Create an arrow.
Parameters
----------
start : sequence[float], default: (0.0, 0.0, 0.0)
Start location in ``[x, y, z]``.
direction : sequence[float], default: (1.0, 0.0, 0.0)
Direction the arrow points to in ``[x, y, z]``.
tip_length : float, default: 0.25
Length of the tip.
tip_radius : float, default: 0.1
Radius of the tip.
tip_resolution : int, default: 20
Number of faces around the tip.
shaft_radius : float, default: 0.05
Radius of the shaft.
shaft_resolution : int, default: 20
Number of faces around the shaft.
scale : float | str, optional
Scale factor of the entire object, defaults to a scale of 1.
``'auto'`` scales to length of direction array.
Returns
-------
pyvista.PolyData
Arrow mesh.
Examples
--------
Plot a default arrow.
>>> import pyvista as pv
>>> mesh = pv.Arrow()
>>> mesh.plot(show_edges=True)
Box(bounds: 'VectorLike[float]' = (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0), level: 'int | VectorLike[int]' = 0, quads: 'bool' = True) -> 'PolyData'
Create a box with solid faces for the given bounds.
Parameters
----------
bounds : sequence[float], default: (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0)
Specify the bounding box of the cube.
``(x_min, x_max, y_min, y_max, z_min, z_max)``.
level : int | VectorLike[int], default: 0
Level of subdivision of the faces.
.. note::
The algorithm is not optimized when a 3 length vector is given.
.. versionadded:: 0.47
Enable specifying different values for x, y and z directions.
quads : bool, default: True
Flag to tell the source to generate either a quad or two
triangle for a set of four points.
Returns
-------
pyvista.PolyData
Mesh of the box.
Examples
--------
Create a box with subdivision ``level=2``.
>>> import pyvista as pv
>>> mesh = pv.Box(level=2)
>>> mesh.plot(show_edges=True)
Set the level separately for each axis.
>>> mesh = pv.Box(level=[1, 2, 3])
>>> mesh.plot(show_edges=True)
Capsule(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0), radius: 'float' = 0.5, cylinder_length: 'float' = 1.0, resolution: 'int' = 30) -> 'PolyData'
Create the surface of a capsule.
.. warning::
:func:`pyvista.Capsule` function rotates the capsule :class:`pyvista.PolyData`
in its own way. It rotates the output 90 degrees in z-axis, translates and
orients the mesh to a new ``center`` and ``direction``.
.. note::
A class:`pyvista.CylinderSource` is used to generate the capsule mesh. For vtk
versions below 9.3, a separate ``pyvista.CapsuleSource`` class is used instead.
The mesh geometries are similar but not identical.
.. versionadded:: 0.44.0
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Location of the centroid in ``[x, y, z]``.
direction : sequence[float], default: (1.0, 0.0, 0.0)
Direction the capsule points to in ``[x, y, z]``.
radius : float, default: 0.5
Radius of the capsule.
cylinder_length : float, default: 1.0
Cylinder length of the capsule.
resolution : int, default: 30
Number of points on the circular face of the cylinder.
Returns
-------
pyvista.PolyData
Capsule surface.
See Also
--------
pyvista.Cylinder
Examples
--------
Create a capsule using default parameters.
>>> import pyvista as pv
>>> capsule = pv.Capsule()
>>> capsule.plot(show_edges=True)
Circle(radius: 'float' = 0.5, resolution: 'int' = 100) -> 'PolyData'
Create a single PolyData circle defined by radius in the XY plane.
Parameters
----------
radius : float, default: 0.5
Radius of circle.
resolution : int, default: 100
Number of points on the circle.
Returns
-------
pyvista.PolyData
Circle mesh.
Notes
-----
.. versionchanged:: 0.38.0
Prior to version 0.38, this method had incorrect results, producing
inconsistent edge lengths and a duplicated point which is now fixed.
Examples
--------
>>> import pyvista as pv
>>> radius = 0.5
>>> circle = pv.Circle(radius=radius)
>>> circle.plot(show_edges=True, line_width=5)
CircularArc(pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int' = 100, negative: 'bool' = False) -> 'PolyData'
Create a circular arc defined by two endpoints and a center.
The number of segments composing the polyline is controlled by
setting the object resolution.
Parameters
----------
pointa : sequence[float]
Position of the first end point.
pointb : sequence[float]
Position of the other end point.
center : sequence[float]
Center of the circle that defines the arc.
resolution : int, default: 100
The number of segments of the polyline that draws the arc.
Resolution of 1 will just create a line.
negative : bool, default: False
By default the arc spans the shortest angular sector between
``pointa`` and ``pointb``.
By setting this to ``True``, the longest angular sector is
used instead (i.e. the negative coterminal angle to the
shortest one).
Returns
-------
pyvista.PolyData
Circular arc mesh.
Examples
--------
Create a quarter arc centered at the origin in the xy plane.
>>> import pyvista as pv
>>> arc = pv.CircularArc(pointa=[-1, 0, 0], pointb=[0, 1, 0], center=[0, 0, 0])
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(arc, color='k', line_width=10)
>>> _ = pl.show_bounds(location='all', font_size=30, use_2d=True)
>>> _ = pl.view_xy()
>>> pl.show()
See :ref:`create_circular_arc_example` and :ref:`flight_paths_example`
for more examples using this function.
CircularArcFromNormal(center: 'VectorLike[float]', resolution: 'int' = 100, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None) -> 'PolyData'
Create a circular arc defined by normal to the plane of the arc, and an angle.
The number of segments composing the polyline is controlled by
setting the object resolution.
Parameters
----------
center : sequence[float]
Center of the circle that defines the arc.
resolution : int, default: 100
The number of segments of the polyline that draws the arc.
Resolution of 1 will just create a line.
normal : sequence[float], optional
The normal vector to the plane of the arc. By default it
points in the positive Z direction.
polar : sequence[float], optional
Starting point of the arc in polar coordinates. By default it
is the unit vector in the positive x direction.
angle : float, optional
Arc length (in degrees) beginning at the polar vector. The
direction is counterclockwise. By default it is 90.
Returns
-------
pyvista.PolyData
Circular arc mesh.
Examples
--------
Quarter arc centered at the origin in the xy plane.
>>> import pyvista as pv
>>> normal = [0, 0, 1]
>>> polar = [-1, 0, 0]
>>> arc = pv.CircularArcFromNormal(
... center=[0, 0, 0], normal=normal, polar=polar
... )
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(arc, color='k', line_width=10)
>>> _ = pl.show_bounds(location='all', font_size=30, use_2d=True)
>>> _ = pl.view_xy()
>>> pl.show()
See :ref:`create_circular_arc_example` for more examples using this function.
Cone(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0), height: 'float' = 1.0, radius: 'float | None' = None, capping: 'bool' = True, angle: 'float | None' = None, resolution: 'int' = 6) -> 'PolyData'
Create a cone.
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Center in ``[x, y, z]``. Axis of the cone passes through this
point.
direction : sequence[float], default: (1.0, 0.0, 0.0)
Direction vector in ``[x, y, z]``. Orientation vector of the
cone.
height : float, default: 1.0
Height along the cone in its specified direction.
radius : float, optional
Base radius of the cone.
capping : bool, optional
Enable or disable the capping the base of the cone with a
polygon.
angle : float, optional
The angle in degrees between the axis of the cone and a
generatrix.
resolution : int, default: 6
Number of facets used to represent the cone.
Returns
-------
pyvista.PolyData
Cone mesh.
Examples
--------
Create a default Cone.
>>> import pyvista as pv
>>> mesh = pv.Cone()
>>> mesh.plot(show_edges=True, line_width=5)
Cube(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), x_length: 'float' = 1.0, y_length: 'float' = 1.0, z_length: 'float' = 1.0, bounds: 'VectorLike[float] | None' = None, clean: 'bool' = True, point_dtype: 'str' = 'float32') -> 'PolyData'
Create a cube.
It's possible to specify either the center and side lengths or
just the bounds of the cube. If ``bounds`` are given, all other
arguments are ignored.
.. versionchanged:: 0.33.0
The cube is created using :vtk:`vtkCubeSource`. For
compatibility with :func:`pyvista.PlatonicSolid`, face indices
are also added as cell data. For full compatibility with
:func:`~pyvista.PlatonicSolid`, one has to
use ``x_length = y_length = z_length = 2 * radius / 3**0.5``.
The cube points are also cleaned by default now, leaving only
the 8 corners and a watertight (manifold) mesh.
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Center in ``[x, y, z]``.
x_length : float, default: 1.0
Length of the cube in the x-direction.
y_length : float, default: 1.0
Length of the cube in the y-direction.
z_length : float, default: 1.0
Length of the cube in the z-direction.
bounds : sequence[float], optional
Specify the bounding box of the cube. If given, all other size
arguments are ignored. ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
clean : bool, default: True
Whether to clean the raw points of the mesh, making the cube
manifold. Note that this will degrade the texture coordinates
that come with the mesh, so if you plan to map a texture on
the cube, consider setting this to ``False``.
.. versionadded:: 0.33.0
point_dtype : str, default: 'float32'
Set the desired output point types. It must be either 'float32' or 'float64'.
.. versionadded:: 0.44.0
Returns
-------
pyvista.PolyData
Mesh of the cube.
Examples
--------
Create a default cube.
>>> import pyvista as pv
>>> mesh = pv.Cube()
>>> mesh.plot(show_edges=True, line_width=5)
Cylinder(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0), radius: 'float' = 0.5, height: 'float' = 1.0, resolution: 'int' = 100, capping: 'bool' = True) -> 'PolyData'
Create the surface of a cylinder.
.. warning::
:func:`pyvista.Cylinder` function rotates the :class:`pyvista.CylinderSource` 's
:class:`pyvista.PolyData` in its own way.
It rotates the :attr:`pyvista.CylinderSource.output` 90 degrees in z-axis, translates and
orients the mesh to a new ``center`` and ``direction``.
See also :func:`pyvista.CylinderStructured`.
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Location of the centroid in ``[x, y, z]``.
direction : sequence[float], default: (1.0, 0.0, 0.0)
Direction cylinder points to in ``[x, y, z]``.
radius : float, default: 0.5
Radius of the cylinder.
height : float, default: 1.0
Height of the cylinder.
resolution : int, default: 100
Number of points on the circular face of the cylinder.
capping : bool, default: True
Cap cylinder ends with polygons.
Returns
-------
pyvista.PolyData
Cylinder surface.
Examples
--------
>>> import pyvista as pv
>>> cylinder = pv.Cylinder(
... center=[1, 2, 3], direction=[1, 1, 1], radius=1, height=2
... )
>>> cylinder.plot(show_edges=True, line_width=5, cpos='xy')
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(
... pv.Cylinder(center=[1, 2, 3], direction=[1, 1, 1], radius=1, height=2),
... show_edges=True,
... line_width=5,
... )
>>> pl.camera_position = 'xy'
>>> pl.show()
The above examples are similar in terms of their behavior.
See :ref:`chemistry_molecule_example` for more examples using this function.
CylinderStructured(radius: 'float' = 0.5, height: 'float' = 1.0, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0), theta_resolution: 'int' = 32, z_resolution: 'int' = 10) -> 'StructuredGrid'
Create a cylinder mesh as a :class:`pyvista.StructuredGrid`.
The end caps are left open. This can create a surface mesh if a single
value for the ``radius`` is given or a 3D mesh if multiple radii are given
as a list/array in the ``radius`` argument.
Parameters
----------
radius : float | sequence[float], default: 0.5
Radius of the cylinder. If a sequence, then describes the
radial coordinates of the cells as a range of values as
specified by the ``radius``.
height : float, default: 1.0
Height of the cylinder along its Z-axis.
center : sequence[float], default: (0.0, 0.0, 0.0)
Location of the centroid in ``[x, y, z]``.
direction : sequence[float], default: (1.0, 0.0, 0.0)
Direction cylinder Z-axis in ``[x, y, z]``.
theta_resolution : int, default: 32
Number of points on the circular face of the cylinder.
Ignored if ``radius`` is an iterable.
z_resolution : int, default: 10
Number of points along the height (Z-axis) of the cylinder.
Returns
-------
pyvista.StructuredGrid
Structured cylinder.
Notes
-----
.. versionchanged:: 0.38.0
Prior to version 0.38, this method had incorrect results, producing
inconsistent number of points on the circular face of the cylinder.
Examples
--------
Default structured cylinder
>>> import pyvista as pv
>>> mesh = pv.CylinderStructured()
>>> mesh.plot(show_edges=True)
Structured cylinder with an inner radius of 1, outer of 2, with 5
segments.
>>> import numpy as np
>>> mesh = pv.CylinderStructured(radius=np.linspace(1, 2, 5))
>>> mesh.plot(show_edges=True)
Disc(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), inner: 'float' = 0.25, outer: 'float' = 0.5, normal: 'VectorLike[float]' = (0.0, 0.0, 1.0), r_res: 'int' = 1, c_res: 'int' = 6) -> 'PolyData'
Create a polygonal disk with a hole in the center.
The disk has zero height. The user can specify the inner and outer
radius of the disk, and the radial and circumferential resolution
of the polygonal representation.
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Center in ``[x, y, z]``. Middle of the axis of the disc.
inner : float, default: 0.25
The inner radius.
outer : float, default: 0.5
The outer radius.
normal : sequence[float], default: (0.0, 0.0, 1.0)
Direction vector in ``[x, y, z]``. Orientation vector of the disc.
r_res : int, default: 1
Number of points in radial direction.
c_res : int, default: 6
Number of points in circumferential direction.
Returns
-------
pyvista.PolyData
Disk mesh.
Examples
--------
Create a disc with 50 points in the circumferential direction.
>>> import pyvista as pv
>>> mesh = pv.Disc(c_res=50)
>>> mesh.plot(show_edges=True, line_width=5)
Dodecahedron(radius: 'float' = 1.0, center: 'VectorLike[float]' = (0.0, 0.0, 0.0)) -> 'PolyData'
Create a dodecahedron of a given size.
A dodecahedron is composed of twelve congruent regular pentagons.
Parameters
----------
radius : float, default: 1.0
The radius of the circumscribed sphere for the dodecahedron.
center : sequence[float], default: (0.0, 0.0, 0.0)
Three-length sequence defining the center of the dodecahedron.
Returns
-------
pyvista.PolyData
Mesh for the dodecahedron. Cell scalars are defined that assign
integer labels to each face (with array name ``"FaceIndex"``).
Examples
--------
Create and plot a dodecahedron.
>>> import pyvista as pv
>>> tetra = pv.Dodecahedron()
>>> tetra.plot(categories=True)
See :ref:`create_platonic_solids_example` for more examples using this filter.
Ellipse(semi_major_axis: 'float' = 0.5, semi_minor_axis: 'float' = 0.2, resolution: 'int' = 100) -> 'PolyData'
Create a single ellipse defined by the Semi-major and Semi-minor axes in the XY plane.
Parameters
----------
semi_major_axis : float, default: 0.5
Semi-major axis of ellipse.
semi_minor_axis : float, default: 0.2
Semi-minor axis of ellipse.
resolution : int, default: 100
Number of points on the ellipse.
Returns
-------
pyvista.PolyData
Ellipse mesh.
Notes
-----
.. versionchanged:: 0.38.0
Prior to version 0.38, this method had incorrect results, producing
inconsistent edge lengths and a duplicated point which is now fixed.
Examples
--------
>>> import pyvista as pv
>>> ellipse = pv.Ellipse(semi_major_axis=8, semi_minor_axis=4)
>>> ellipse.plot(show_edges=True, line_width=5)
Icosahedron(radius: 'float' = 1.0, center: 'VectorLike[float]' = (0.0, 0.0, 0.0)) -> 'PolyData'
Create an icosahedron of a given size.
An icosahedron is composed of twenty congruent equilateral
triangles.
Parameters
----------
radius : float, default: 1.0
The radius of the circumscribed sphere for the icosahedron.
center : sequence[float], default: (0.0, 0.0, 0.0)
Three-length sequence defining the center of the icosahedron.
Returns
-------
pyvista.PolyData
Mesh for the icosahedron. Cell scalars are defined that assign
integer labels to each face (with array name ``"FaceIndex"``).
Examples
--------
Create and plot an icosahedron.
>>> import pyvista as pv
>>> tetra = pv.Icosahedron()
>>> tetra.plot(categories=True)
See :ref:`create_platonic_solids_example` for more examples using this filter.
Icosphere(radius: 'float' = 1.0, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), nsub: 'int' = 3) -> 'PolyData'
Create an icosphere.
An icosphere is a `geodesic polyhedron
<https://en.wikipedia.org/wiki/Geodesic_polyhedron>`_, which is a
convex polyhedron made from triangles.
Geodesic polyhedra are constructed by subdividing faces of simpler
polyhedra, and then projecting the new vertices onto the surface of
a sphere. A geodesic polyhedron has straight edges and flat faces
that approximate a sphere,
Parameters
----------
radius : float, default: 1.0
Radius of the icosphere.
center : sequence[float], default: (0.0, 0.0, 0.0)
Center of the icosphere.
nsub : int, default: 3
This is the number of times each triangle of the original
:func:`pyvista.Icosahedron` is subdivided.
Returns
-------
pyvista.PolyData
Mesh of the icosphere.
See Also
--------
pyvista.Sphere
Examples
--------
Create the icosphere and plot it with edges.
>>> import pyvista as pv
>>> icosphere = pv.Icosphere()
>>> icosphere.plot(show_edges=True)
Show how this icosphere was created.
>>> import numpy as np
>>> icosahedron = pv.Icosahedron()
>>> icosahedron.clear_data() # remove extra scalars
>>> icosahedron_sub = icosahedron.subdivide(nsub=3)
>>> pl = pv.Plotter(shape=(1, 3))
>>> _ = pl.add_mesh(icosahedron, show_edges=True)
>>> pl.subplot(0, 1)
>>> _ = pl.add_mesh(icosahedron_sub, show_edges=True)
>>> pl.subplot(0, 2)
>>> _ = pl.add_mesh(icosphere, show_edges=True)
>>> pl.show()
Show how the triangles are not uniform in area. This is because the
ones farther from the edges from the original triangles have farther
to travel to the sphere.
>>> icosphere = pv.Icosphere(nsub=4)
>>> icosphere.compute_cell_sizes().plot(scalars='Area')
Line(pointa: 'VectorLike[float]' = (-0.5, 0.0, 0.0), pointb: 'VectorLike[float]' = (0.5, 0.0, 0.0), resolution: 'int' = 1) -> 'PolyData'
Create a line.
Parameters
----------
pointa : sequence[float], default: (-0.5, 0.0, 0.0)
Location in ``[x, y, z]``.
pointb : sequence[float], default: (0.5, 0.0, 0.0)
Location in ``[x, y, z]``.
resolution : int, default: 1
Number of pieces to divide line into.
Returns
-------
pyvista.PolyData
Line mesh.
Examples
--------
Create a line between ``(0, 0, 0)`` and ``(0, 0, 1)``.
>>> import pyvista as pv
>>> mesh = pv.Line((0, 0, 0), (0, 0, 1))
>>> mesh.plot(color='k', line_width=10)
MultipleLines(points: 'MatrixLike[float] | None' = None) -> 'PolyData'
Create multiple lines.
Parameters
----------
points : array_like[float], default: [[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]]
List of points defining a broken line.
Returns
-------
pyvista.PolyData
Line mesh.
Examples
--------
Create a multiple lines between ``(0, 0, 0)``, ``(1, 1, 1)`` and ``(0, 0, 1)``.
>>> import pyvista as pv
>>> mesh = pv.MultipleLines(points=[[0, 0, 0], [1, 1, 1], [0, 0, 1]])
>>> pl = pv.Plotter()
>>> actor = pl.add_mesh(mesh, color='k', line_width=10)
>>> pl.camera.azimuth = 45
>>> pl.camera.zoom(0.8)
>>> pl.show()
See :ref:`create_multiple_lines_example` and :ref:`color_lines_example`
for more examples.
Octahedron(radius: 'float' = 1.0, center: 'VectorLike[float]' = (0.0, 0.0, 0.0)) -> 'PolyData'
Create an octahedron of a given size.
An octahedron is composed of eight congruent equilateral
triangles.
Parameters
----------
radius : float, default: 1.0
The radius of the circumscribed sphere for the octahedron.
center : sequence[float], default: (0.0, 0.0, 0.0)
Three-length sequence defining the center of the octahedron.
Returns
-------
pyvista.PolyData
Mesh for the octahedron. Cell scalars are defined that assign
integer labels to each face (with array name ``"FaceIndex"``).
Examples
--------
Create and plot an octahedron.
>>> import pyvista as pv
>>> tetra = pv.Octahedron()
>>> tetra.plot(categories=True)
See :ref:`create_platonic_solids_example` for more examples using this filter.
Plane(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (0.0, 0.0, 1.0), i_size: 'float' = 1.0, j_size: 'float' = 1.0, i_resolution: 'int' = 10, j_resolution: 'int' = 10) -> 'PolyData'
Create a plane.
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Location of the centroid in ``[x, y, z]``.
direction : sequence[float], default: (0.0, 0.0, 1.0)
Direction of the plane's normal in ``[x, y, z]``.
i_size : float, default: 1.0
Size of the plane in the i direction.
j_size : float, default: 1.0
Size of the plane in the j direction.
i_resolution : int, default: 10
Number of points on the plane in the i direction.
j_resolution : int, default: 10
Number of points on the plane in the j direction.
Returns
-------
pyvista.PolyData
Plane mesh.
Examples
--------
Create a default plane.
>>> import pyvista as pv
>>> mesh = pv.Plane()
>>> mesh.point_data.clear()
>>> mesh.plot(show_edges=True)
PlatonicSolid(kind: 'str' = 'tetrahedron', radius: 'float' = 1.0, center: 'VectorLike[float]' = (0.0, 0.0, 0.0)) -> 'PolyData'
Create a Platonic solid of a given size.
Parameters
----------
kind : str | int, default: 'tetrahedron'
The kind of Platonic solid to create. Either the name of the
polyhedron or an integer index:
* ``'tetrahedron'`` or ``0``
* ``'cube'`` or ``1``
* ``'octahedron'`` or ``2``
* ``'icosahedron'`` or ``3``
* ``'dodecahedron'`` or ``4``
radius : float, default: 1.0
The radius of the circumscribed sphere for the solid to create.
center : sequence[float], default: (0.0, 0.0, 0.0)
Sequence defining the center of the solid to create.
Returns
-------
pyvista.PolyData
One of the five Platonic solids. Cell scalars are defined that
assign integer labels to each face (with array name
``"FaceIndex"``).
Examples
--------
Create and plot a dodecahedron.
>>> import pyvista as pv
>>> dodeca = pv.PlatonicSolid('dodecahedron')
>>> dodeca.plot(categories=True)
See :ref:`create_platonic_solids_example` for more examples using this filter.
Polygon(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), radius: 'float' = 1.0, normal: 'VectorLike[float]' = (0.0, 0.0, 1.0), n_sides: 'int' = 6, fill: 'bool' = True) -> 'PolyData'
Create a polygon.
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Center in ``[x, y, z]``. Central axis of the polygon passes
through this point.
radius : float, default: 1.0
The radius of the polygon.
normal : sequence[float], default: (0.0, 0.0, 1.0)
Direction vector in ``[x, y, z]``. Orientation vector of the polygon.
n_sides : int, default: 6
Number of sides of the polygon.
fill : bool, default: True
Enable or disable producing filled polygons.
Returns
-------
pyvista.PolyData
Mesh of the polygon.
Examples
--------
Create an 8 sided polygon.
>>> import pyvista as pv
>>> mesh = pv.Polygon(n_sides=8)
>>> mesh.plot(show_edges=True, line_width=5)
Pyramid(points: 'MatrixLike[float] | None' = None) -> 'UnstructuredGrid'
Create a pyramid defined by 5 points.
Parameters
----------
points : array_like[float], optional
Points of the pyramid. Points are ordered such that the first
four points are the four counterclockwise points on the
quadrilateral face, and the last point is the apex.
Defaults to pyramid in example.
Returns
-------
pyvista.UnstructuredGrid
Unstructured grid containing a single pyramid cell.
Examples
--------
>>> import pyvista as pv
>>> pointa = [1.0, 1.0, 0.0]
>>> pointb = [-1.0, 1.0, 0.0]
>>> pointc = [-1.0, -1.0, 0.0]
>>> pointd = [1.0, -1.0, 0.0]
>>> pointe = [0.0, 0.0, 1.608]
>>> pyramid = pv.Pyramid([pointa, pointb, pointc, pointd, pointe])
>>> pyramid.plot(show_edges=True, line_width=5)
Quadrilateral(points: 'MatrixLike[float] | None' = None) -> 'PolyData'
Create a quadrilateral defined by 4 points.
Parameters
----------
points : array_like[float], optional
Points of the quadrilateral. Defaults to a unit square in xy-plane.
Returns
-------
pyvista.PolyData
Quadrilateral mesh.
Examples
--------
>>> import pyvista as pv
>>> pointa = [1.0, 0.0, 0.0]
>>> pointb = [1.0, 1.0, 0.0]
>>> pointc = [0.0, 1.0, 0.0]
>>> pointd = [0.0, 0.0, 0.0]
>>> quadrilateral = pv.Quadrilateral([pointa, pointb, pointc, pointd])
>>> quadrilateral.plot(show_edges=True, line_width=5)
Rectangle(points: 'MatrixLike[float] | None' = None) -> 'PolyData'
Create a rectangle defined by 3 points.
The 3 points must define an orthogonal set of vectors.
Parameters
----------
points : array_like[float], optional
Points of the rectangle. Defaults to a unit square in xy-plane.
Returns
-------
pyvista.PolyData
Rectangle mesh.
Examples
--------
>>> import pyvista as pv
>>> pointa = [1.0, 0.0, 0.0]
>>> pointb = [1.0, 1.0, 0.0]
>>> pointc = [0.0, 1.0, 0.0]
>>> rectangle = pv.Rectangle([pointa, pointb, pointc])
>>> rectangle.plot(show_edges=True, line_width=5)
SolidSphere(outer_radius: 'float' = 0.5, inner_radius: 'float' = 0.0, radius_resolution: 'int' = 5, start_theta: 'float' = 0.0, end_theta: 'float | None' = None, theta_resolution: 'int' = 30, start_phi: 'float' = 0.0, end_phi: 'float | None' = None, phi_resolution: 'int' = 30, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (0.0, 0.0, 1.0), radians: 'bool' = False, tol_radius: 'float' = 1e-08, tol_angle: 'float | None' = None) -> 'UnstructuredGrid'
Create a solid sphere.
A solid sphere fills space in 3D in comparison to
:func:`pyvista.Sphere`, which is a 2D surface.
This function uses a linear sampling of each spherical
coordinate, whereas :func:`pyvista.SolidSphereGeneric`
allows for nonuniform sampling. Angles are by default
specified in degrees.
PyVista uses a convention where ``theta`` represents the azimuthal
angle (similar to degrees longitude on the globe) and ``phi``
represents the polar angle (similar to degrees latitude on the
globe). In contrast to latitude on the globe, here
``phi`` is 0 degrees at the North Pole and 180 degrees at the South
Pole. ``phi=0`` is on the positive z-axis by default.
``theta=0`` is on the positive x-axis by default.
While values for theta can be any value with a maximum span of
360 degrees, large magnitudes may result in problems with endpoint
overlap detection.
Parameters
----------
outer_radius : float, default: 0.5
Outer radius of sphere. Must be non-negative.
inner_radius : float, default: 0.0
Inner radius of sphere. Must be non-negative
and smaller than ``outer_radius``.
radius_resolution : int, default: 5
Number of points in radial direction.
start_theta : float, default: 0.0
Starting azimuthal angle.
end_theta : float, default: 360.0
Ending azimuthal angle.
``end_theta`` must be greater than ``start_theta``.
theta_resolution : int, default: 30
Number of points in ``theta`` direction.
start_phi : float, default: 0.0
Starting polar angle.
``phi`` must lie between 0 and 180 in degrees.
end_phi : float, default: 180.0
Ending polar angle.
``phi`` must lie between 0 and 180 in degrees.
``end_phi`` must be greater than ``start_phi``.
phi_resolution : int, default: 30
Number of points in ``phi`` direction,
inclusive of polar axis, i.e. ``phi=0`` and ``phi=180``
in degrees, if applicable.
center : sequence[float], default: (0.0, 0.0, 0.0)
Center coordinate vector in ``[x, y, z]``.
direction : sequence[float], default: (0.0, 0.0, 1.0)
Direction coordinate vector in ``[x, y, z]`` pointing from ``center`` to
the sphere's north pole at zero degrees ``phi``.
radians : bool, default: False
Whether to use radians for ``theta`` and ``phi``. Default is degrees.
tol_radius : float, default: 1.0e-8
Absolute tolerance for endpoint detection for ``radius``.
tol_angle : float, optional
Absolute tolerance for endpoint detection
for ``phi`` and ``theta``. Unit is determined by choice
of ``radians`` parameter. Default is 1.0e-8 degrees or
1.0e-8 degrees converted to radians.
Returns
-------
pyvista.UnstructuredGrid
Solid sphere mesh.
See Also
--------
pyvista.Sphere: Sphere that describes outer 2D surface.
pyvista.SolidSphereGeneric: Uses more flexible parameter definition.
Examples
--------
Create a solid sphere.
>>> import pyvista as pv
>>> import numpy as np
>>> solid_sphere = pv.SolidSphere()
>>> solid_sphere.plot(show_edges=True)
A solid sphere is 3D in comparison to the 2d :func:`pyvista.Sphere`.
Generate a solid hemisphere to see the internal structure.
>>> isinstance(solid_sphere, pv.UnstructuredGrid)
True
>>> partial_solid_sphere = pv.SolidSphere(start_theta=180, end_theta=360)
>>> partial_solid_sphere.plot(show_edges=True)
To see the cell structure inside the solid sphere,
only 1/4 of the sphere is generated. The cells are exploded
and colored by radial position.
>>> partial_solid_sphere = pv.SolidSphere(
... start_theta=180,
... end_theta=360,
... start_phi=0,
... end_phi=90,
... radius_resolution=5,
... theta_resolution=8,
... phi_resolution=8,
... )
>>> partial_solid_sphere['cell_radial_pos'] = np.linalg.norm(
... partial_solid_sphere.cell_centers().points, axis=-1
... )
>>> partial_solid_sphere.explode(1).plot()
SolidSphereGeneric(radius: 'VectorLike[float] | None' = None, theta: 'VectorLike[float] | None' = None, phi: 'VectorLike[float] | None' = None, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (0.0, 0.0, 1.0), radians: 'bool' = False, tol_radius: 'float' = 1e-08, tol_angle: 'float | None' = None) -> 'UnstructuredGrid'
Create a solid sphere with flexible sampling.
A solid sphere fills space in 3D in comparison to
:func:`pyvista.Sphere`, which is a 2D surface.
This function allows user defined sampling of each spherical
coordinate, whereas :func:`pyvista.SolidSphere`
only allows linear sampling. Angles are by default
specified in degrees.
PyVista uses a convention where ``theta`` represents the azimuthal
angle (similar to degrees longitude on the globe) and ``phi``
represents the polar angle (similar to degrees latitude on the
globe). In contrast to latitude on the globe, here
``phi`` is 0 degrees at the North Pole and 180 degrees at the South
Pole. ``phi=0`` is on the positive z-axis by default.
``theta=0`` is on the positive x-axis by default.
Parameters
----------
radius : sequence[float], optional
A monotonically increasing sequence of values specifying radial
points. Must have at least two points and be non-negative.
theta : sequence[float], optional
A monotonically increasing sequence of values specifying ``theta``
points. Must have at least two points. Can have any value as long
as range is within 360 degrees. Large magnitudes may result in
problems with endpoint overlap detection.
phi : sequence[float], optional
A monotonically increasing sequence of values specifying ``phi``
points. Must have at least two points. Must be between
0 and 180 degrees.
center : sequence[float], default: (0.0, 0.0, 0.0)
Center coordinate vector in ``[x, y, z]``.
direction : sequence[float], default: (0.0, 0.0, 1.0)
Direction coordinate vector in ``[x, y, z]`` pointing from ``center`` to
the sphere's north pole at zero degrees ``phi``.
radians : bool, default: False
Whether to use radians for ``theta`` and ``phi``. Default is degrees.
tol_radius : float, default: 1.0e-8
Absolute tolerance for endpoint detection for ``radius``.
tol_angle : float, optional
Absolute tolerance for endpoint detection
for ``phi`` and ``theta``. Unit is determined by choice
of ``radians`` parameter. Default is 1.0e-8 degrees or
1.0e-8 degrees converted to radians.
Returns
-------
pyvista.UnstructuredGrid
Solid sphere mesh.
See Also
--------
pyvista.SolidSphere: Sphere creation using linear sampling.
pyvista.Sphere: Sphere that describes outer 2D surface.
Examples
--------
Linearly sampling spherical coordinates does not lead to
cells of all the same size at each radial position.
Cells near the poles have smaller sizes.
>>> import pyvista as pv
>>> import numpy as np
>>> solid_sphere = pv.SolidSphereGeneric(
... radius=np.linspace(0, 0.5, 2),
... theta=np.linspace(180, 360, 30),
... phi=np.linspace(0, 180, 30),
... )
>>> solid_sphere = solid_sphere.compute_cell_sizes()
>>> solid_sphere.plot(scalars='Volume', show_edges=True, clim=[3e-5, 5e-4])
Sampling the polar angle in a nonlinear manner allows for consistent cell volumes. See
`Sphere Point Picking <https://mathworld.wolfram.com/SpherePointPicking.html>`_.
>>> phi = np.rad2deg(np.arccos(np.linspace(1, -1, 30)))
>>> solid_sphere = pv.SolidSphereGeneric(
... radius=np.linspace(0, 0.5, 2),
... theta=np.linspace(180, 360, 30),
... phi=phi,
... )
>>> solid_sphere = solid_sphere.compute_cell_sizes()
>>> solid_sphere.plot(scalars='Volume', show_edges=True, clim=[3e-5, 5e-4])
Sphere(radius: 'float' = 0.5, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (0.0, 0.0, 1.0), theta_resolution: 'int' = 30, phi_resolution: 'int' = 30, start_theta: 'float' = 0.0, end_theta: 'float' = 360.0, start_phi: 'float' = 0.0, end_phi: 'float' = 180.0) -> 'PolyData'
Create a sphere.
A sphere describes a 2D surface in comparison to
:func:`pyvista.SolidSphere`, which fills a 3D volume.
PyVista uses a convention where ``theta`` represents the azimuthal
angle (similar to degrees longitude on the globe) and ``phi``
represents the polar angle (similar to degrees latitude on the
globe). In contrast to latitude on the globe, here
``phi`` is 0 degrees at the North Pole and 180 degrees at the South
Pole. ``phi=0`` is on the positive z-axis by default.
``theta=0`` is on the positive x-axis by default.
See :ref:`create_sphere_example` for examples on creating spheres in
other ways.
Parameters
----------
radius : float, default: 0.5
Sphere radius.
center : sequence[float], default: (0.0, 0.0, 0.0)
Center coordinate vector in ``[x, y, z]``.
direction : sequence[float], default: (0.0, 0.0, 1.0)
Direction coordinate vector in ``[x, y, z]`` pointing from ``center`` to
the sphere's north pole at zero degrees ``phi``.
theta_resolution : int, default: 30
Set the number of points in the azimuthal direction (ranging
from ``start_theta`` to ``end_theta``).
phi_resolution : int, default: 30
Set the number of points in the polar direction (ranging from
``start_phi`` to ``end_phi``).
start_theta : float, default: 0.0
Starting azimuthal angle in degrees ``[0, 360]``.
end_theta : float, default: 360.0
Ending azimuthal angle in degrees ``[0, 360]``.
start_phi : float, default: 0.0
Starting polar angle in degrees ``[0, 180]``.
end_phi : float, default: 180.0
Ending polar angle in degrees ``[0, 180]``.
Returns
-------
pyvista.PolyData
Sphere mesh.
See Also
--------
pyvista.Icosphere : Sphere created from projection of icosahedron.
pyvista.SolidSphere : Sphere that fills 3D space.
:ref:`sphere_eversion_example` : Example turning a sphere inside-out.
Examples
--------
Create a sphere using default parameters.
>>> import pyvista as pv
>>> sphere = pv.Sphere()
>>> sphere.plot(show_edges=True)
Create a quarter sphere by setting ``end_theta``.
>>> sphere = pv.Sphere(end_theta=90)
>>> out = sphere.plot(show_edges=True)
Create a hemisphere by setting ``end_phi``.
>>> sphere = pv.Sphere(end_phi=90)
>>> out = sphere.plot(show_edges=True)
Superquadric(center: 'VectorLike[float]' = (0.0, 0.0, 0.0), scale: 'VectorLike[float]' = (1.0, 1.0, 1.0), size: 'float' = 0.5, theta_roundness: 'float' = 1.0, phi_roundness: 'float' = 1.0, theta_resolution: 'int' = 16, phi_resolution: 'int' = 16, toroidal: 'bool' = False, thickness: 'float' = 0.3333333333333333) -> 'PolyData'
Create a superquadric.
Parameters
----------
center : sequence[float], default: (0.0, 0.0, 0.0)
Center of the superquadric in ``[x, y, z]``.
scale : sequence[float], default: (1.0, 1.0, 1.0)
Scale factors of the superquadric in ``[x, y, z]``.
size : float, default: 0.5
Superquadric isotropic size.
theta_roundness : float, default: 1.0
Superquadric east/west roundness.
Values range from 0 (rectangular) to 1 (circular) to higher orders.
phi_roundness : float, default: 1.0
Superquadric north/south roundness.
Values range from 0 (rectangular) to 1 (circular) to higher orders.
theta_resolution : int, default: 16
Number of points in the longitude direction.
Values are rounded to nearest multiple of 4.
phi_resolution : int, default: 16
Number of points in the latitude direction.
Values are rounded to nearest multiple of 8.
toroidal : bool, default: False
Whether or not the superquadric is toroidal (``True``)
or ellipsoidal (``False``).
thickness : float, default: 0.3333333333
Superquadric ring thickness.
Only applies if toroidal is set to ``True``.
Returns
-------
pyvista.PolyData
Superquadric mesh.
See Also
--------
pyvista.ParametricSuperEllipsoid :
Parametric superquadric if toroidal is ``False``.
pyvista.ParametricSuperToroid :
Parametric superquadric if toroidal is ``True``.
Examples
--------
>>> import pyvista as pv
>>> superquadric = pv.Superquadric(
... scale=(3.0, 1.0, 0.5),
... phi_roundness=0.1,
... theta_roundness=0.5,
... )
>>> superquadric.plot(show_edges=True)
Tetrahedron(radius: 'float' = 1.0, center: 'VectorLike[float]' = (0.0, 0.0, 0.0)) -> 'PolyData'
Create a tetrahedron of a given size.
A tetrahedron is composed of four congruent equilateral triangles.
Parameters
----------
radius : float, default: 1.0
The radius of the circumscribed sphere for the tetrahedron.
center : sequence[float], default: (0.0, 0.0, 0.0)
Three-length sequence defining the center of the tetrahedron.
Returns
-------
pyvista.PolyData
Mesh for the tetrahedron. Cell scalars are defined that assign
integer labels to each face (with array name ``"FaceIndex"``).
Examples
--------
Create and plot a tetrahedron.
>>> import pyvista as pv
>>> tetra = pv.Tetrahedron()
>>> tetra.plot(categories=True)
See :ref:`create_platonic_solids_example` for more examples using this filter.
Text3D(string: 'str', depth: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), normal: 'VectorLike[float]' = (0.0, 0.0, 1.0)) -> 'PolyData'
Create 3D text from a string.
The text may be configured to have a specified width, height or depth.
Parameters
----------
string : str
String to generate 3D text from. If ``None`` or an empty string,
the output mesh will have a single point at ``center``.
depth : float, optional
Depth of the text. If ``None``, the depth is set to half
the ``height`` by default. Set to ``0.0`` for planar
text.
.. versionchanged:: 0.43
The default depth is now calculated dynamically as
half the height. Previously, the default depth had
a fixed value of ``0.5``.
width : float, optional
Width of the text. If ``None``, the width is scaled
proportional to ``height``.
.. versionadded:: 0.43
height : float, optional
Height of the text. If ``None``, the height is scaled
proportional to ``width``.
.. versionadded:: 0.43
center : Sequence[float], default: (0.0, 0.0, 0.0)
Center of the text, defined as the middle of the axis-aligned
bounding box of the text.
.. versionadded:: 0.43
normal : Sequence[float], default: (0.0, 0.0, 1.0)
Normal direction of the text. The direction is parallel to the
``depth`` of the text and points away from the front surface
of the text.
.. versionadded:: 0.43
Returns
-------
pyvista.PolyData
3D text mesh.
Examples
--------
Create 3D text.
>>> import pyvista as pv
>>> text_mesh = pv.Text3D('PyVista')
>>> text_mesh.plot(cpos='xy', show_bounds=True)
Create planar text.
>>> text_mesh = pv.Text3D('PyVista', depth=0)
>>> text_mesh.plot(cpos='xy', show_bounds=True)
Set the depth explicitly.
>>> text_mesh = pv.Text3D('PyVista', depth=5)
>>> text_mesh.plot(cpos='xy', show_bounds=True)
Set the width explicitly. The height and depth are automatically scaled proportionally.
>>> text_mesh = pv.Text3D('PyVista', width=10)
>>> text_mesh.plot(cpos='xy', show_bounds=True)
Set the height explicitly. The width and depth are automatically scaled proportionally.
>>> text_mesh = pv.Text3D('PyVista', height=10)
>>> text_mesh.plot(cpos='xy', show_bounds=True)
Set the height `and` width. The depth is automatically scaled proportional to height.
>>> text_mesh = pv.Text3D('PyVista', height=10, width=10)
>>> text_mesh.plot(cpos='xy', show_bounds=True)
Set the height, width, and depth independently, and adjust the center.
>>> text_mesh = pv.Text3D(
... 'PyVista', height=10, width=10, depth=0, center=(5, 5, 0)
... )
>>> text_mesh.plot(cpos='xy', show_bounds=True)
See :ref:`create_text_3d_example` for more examples using this function.
Triangle(points: 'MatrixLike[float] | None' = None) -> 'PolyData'
Create a triangle defined by 3 points.
Parameters
----------
points : array_like[float], optional
Points of the triangle. Defaults to a right isosceles
triangle (see example).
Returns
-------
pyvista.PolyData
Triangle mesh.
Examples
--------
>>> import pyvista as pv
>>> pointa = [0, 0, 0]
>>> pointb = [1, 0, 0]
>>> pointc = [0.5, 0.707, 0]
>>> triangle = pv.Triangle([pointa, pointb, pointc])
>>> triangle.plot(show_edges=True, line_width=5)
Tube(pointa: 'VectorLike[float]' = (-0.5, 0.0, 0.0), pointb: 'VectorLike[float]' = (0.5, 0.0, 0.0), resolution: 'int' = 1, radius: 'float' = 1.0, n_sides: 'int' = 15, capping: 'bool' = False) -> 'PolyData'
Create a tube.
Parameters
----------
pointa : sequence[float], default: (-0.5, 0.0, 0.0)
Location in ``[x, y, z]``.
pointb : sequence[float], default: (0.5, 0.0, 0.0)
Location in ``[x, y, z]``.
resolution : int, default: 1
Number of pieces to divide tube into.
radius : float, default: 1.0
Minimum tube radius (minimum because the tube radius may vary).
n_sides : int, default: 15
Number of sides for the tube.
capping : bool, default: False
Turn on/off whether to cap the ends with polygons.
.. versionadded:: 0.45
Returns
-------
pyvista.PolyData
Tube mesh.
Examples
--------
Create a tube between ``(0, 0, 0)`` and ``(0, 0, 1)``.
>>> import pyvista as pv
>>> mesh = pv.Tube(pointa=(0, 0, 0), pointb=(0, 0, 1))
>>> mesh.plot()
Wavelet(extent: 'VectorLike[float]' = (-10, 10, -10, 10, -10, 10), center: 'VectorLike[float]' = (0.0, 0.0, 0.0), maximum: 'float' = 255.0, x_freq: 'float' = 60.0, y_freq: 'float' = 30.0, z_freq: 'float' = 40.0, x_mag: 'float' = 10.0, y_mag: 'float' = 18.0, z_mag: 'float' = 5.0, std: 'float' = 0.5, subsample_rate: 'int' = 1) -> 'ImageData'
Create a wavelet.
Produces images with pixel values determined by
``Maximum*Gaussian*x_mag*sin(x_freq*x)*sin(y_freq*y)*cos(z_freq*z)``
Values are float scalars on point data with name ``"RTData"``.
Parameters
----------
extent : sequence[int], default: (-10, 10, -10, 10, -10, 10)
Set/Get the extent of the whole output image.
center : sequence[float], default: (0.0, 0.0, 0.0)
Center of the wavelet.
maximum : float, default: 255.0
Maximum of the wavelet function.
x_freq : float, default: 60.0
Natural frequency in the x direction.
y_freq : float, default: 30.0
Natural frequency in the y direction.
z_freq : float, default: 40.0
Natural frequency in the z direction.
x_mag : float, default: 10.0
Magnitude in the x direction.
y_mag : float, default: 18.0
Magnitude in the y direction.
z_mag : float, default: 5.0
Magnitude in the z direction.
std : float, default: 0.5
Standard deviation.
subsample_rate : int, default: 1
The sub-sample rate.
Returns
-------
pyvista.ImageData
Wavelet mesh.
Examples
--------
>>> import pyvista as pv
>>> wavelet = pv.Wavelet(
... extent=(0, 50, 0, 50, 0, 10),
... x_freq=20,
... y_freq=10,
... z_freq=1,
... x_mag=100,
... y_mag=100,
... z_mag=1000,
... )
>>> wavelet.plot(show_scalar_bar=False)
Extract lower valued cells of the wavelet and create a surface from it.
>>> thresh = wavelet.threshold(800).extract_surface(algorithm=None)
>>> thresh.plot(show_scalar_bar=False)
Smooth it to create "waves"
>>> waves = thresh.smooth(n_iter=100, relaxation_factor=0.1)
>>> waves.plot(color='white', smooth_shading=True, show_edges=True)
DATA
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
TYPE_CHECKING = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\geometric_objects.py
pyvista.geometric_sources
Python Library Documentation: module pyvista.core.utilities.geometric_sources in pyvista.core.utilities
NAME
pyvista.core.utilities.geometric_sources - Provides an easy way of generating several geometric sources.
DESCRIPTION
Also includes some pure-python helpers.
CLASSES
pyvista.core._vtk_utilities.DisableVtkSnakeCase(builtins.object)
ArrowSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkArrowSource)
BoxSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource)
ConeSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkConeSource)
CubeSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkCubeSource)
CubeFacesSource
CylinderSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkCylinderSource)
DiscSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkDiskSource)
LineSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkLineSource)
MultipleLinesSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkLineSource)
PlaneSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkPlaneSource)
PlatonicSolidSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource)
PolygonSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkRegularPolygonSource)
SphereSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkSphereSource)
SuperquadricSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkSuperquadricSource)
pyvista.core.utilities.misc._NoNewAttrMixin(builtins.object)
ArrowSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkArrowSource)
AxesGeometrySource
BoxSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource)
ConeSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkConeSource)
CubeSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkCubeSource)
CubeFacesSource
CylinderSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkCylinderSource)
DiscSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkDiskSource)
LineSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkLineSource)
MultipleLinesSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkLineSource)
OrthogonalPlanesSource
PlaneSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkPlaneSource)
PlatonicSolidSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource)
PolygonSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkRegularPolygonSource)
SphereSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkSphereSource)
SuperquadricSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkSuperquadricSource)
Text3DSource
vtkmodules.vtkFiltersSources.vtkArrowSource(vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm)
ArrowSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkArrowSource)
vtkmodules.vtkFiltersSources.vtkConeSource(vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm)
ConeSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkConeSource)
vtkmodules.vtkFiltersSources.vtkCubeSource(vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm)
CubeSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkCubeSource)
CubeFacesSource
vtkmodules.vtkFiltersSources.vtkCylinderSource(vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm)
CylinderSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkCylinderSource)
vtkmodules.vtkFiltersSources.vtkDiskSource(vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm)
DiscSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkDiskSource)
vtkmodules.vtkFiltersSources.vtkLineSource(vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm)
LineSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkLineSource)
MultipleLinesSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkLineSource)
vtkmodules.vtkFiltersSources.vtkPlaneSource(vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm)
PlaneSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkPlaneSource)
vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource(vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm)
PlatonicSolidSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource)
vtkmodules.vtkFiltersSources.vtkRegularPolygonSource(vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm)
PolygonSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkRegularPolygonSource)
vtkmodules.vtkFiltersSources.vtkSphereSource(vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm)
SphereSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkSphereSource)
vtkmodules.vtkFiltersSources.vtkSuperquadricSource(vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm)
SuperquadricSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkSuperquadricSource)
vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource(vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm)
BoxSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource)
class ArrowSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkArrowSource)
| ArrowSource(*args, **kwargs) -> '_T'
|
| Create a arrow source.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| tip_length : float, default: 0.25
| Length of the tip.
|
| tip_radius : float, default: 0.1
| Radius of the tip.
|
| tip_resolution : int, default: 20
| Number of faces around the tip.
|
| shaft_radius : float, default: 0.05
| Radius of the shaft.
|
| shaft_resolution : int, default: 20
| Number of faces around the shaft.
|
| Method resolution order:
| ArrowSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkArrowSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'ArrowSource', tip_length: 'float' = 0.25, tip_radius: 'float' = 0.1, tip_resolution: 'int' = 20, shaft_radius: 'float' = 0.05, shaft_resolution: 'int' = 20) -> 'None'
| Initialize source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Plane mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| shaft_radius
| Get the radius of the shaft.
|
| Returns
| -------
| int
| The radius of the shaft.
|
| shaft_resolution
| Get the number of faces around the shaft.
|
| Returns
| -------
| int
| The number of faces around the shaft.
|
| tip_length
| Get the length of the tip.
|
| Returns
| -------
| int
| The length of the tip.
|
| tip_radius
| Get the radius of the tip.
|
| Returns
| -------
| int
| The radius of the tip.
|
| tip_resolution
| Get the number of faces around the tip.
|
| Returns
| -------
| int
| The number of faces around the tip.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkArrowSource:
|
| GetArrowOrigin(...)
| GetArrowOrigin(self) -> ArrowOrigins
| C++: virtual ArrowOrigins GetArrowOrigin()
|
| GetArrowOriginAsString(...)
| GetArrowOriginAsString(self) -> str
| C++: std::string GetArrowOriginAsString()
|
| GetInvert(...)
| GetInvert(self) -> bool
| C++: virtual bool GetInvert()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetShaftRadius(...)
| GetShaftRadius(self) -> float
| C++: virtual double GetShaftRadius()
|
| GetShaftRadiusMaxValue(...)
| GetShaftRadiusMaxValue(self) -> float
| C++: virtual double GetShaftRadiusMaxValue()
|
| GetShaftRadiusMinValue(...)
| GetShaftRadiusMinValue(self) -> float
| C++: virtual double GetShaftRadiusMinValue()
|
| GetShaftResolution(...)
| GetShaftResolution(self) -> int
| C++: virtual int GetShaftResolution()
|
| GetShaftResolutionMaxValue(...)
| GetShaftResolutionMaxValue(self) -> int
| C++: virtual int GetShaftResolutionMaxValue()
|
| GetShaftResolutionMinValue(...)
| GetShaftResolutionMinValue(self) -> int
| C++: virtual int GetShaftResolutionMinValue()
|
| GetTipLength(...)
| GetTipLength(self) -> float
| C++: virtual double GetTipLength()
|
| GetTipLengthMaxValue(...)
| GetTipLengthMaxValue(self) -> float
| C++: virtual double GetTipLengthMaxValue()
|
| GetTipLengthMinValue(...)
| GetTipLengthMinValue(self) -> float
| C++: virtual double GetTipLengthMinValue()
|
| GetTipRadius(...)
| GetTipRadius(self) -> float
| C++: virtual double GetTipRadius()
|
| GetTipRadiusMaxValue(...)
| GetTipRadiusMaxValue(self) -> float
| C++: virtual double GetTipRadiusMaxValue()
|
| GetTipRadiusMinValue(...)
| GetTipRadiusMinValue(self) -> float
| C++: virtual double GetTipRadiusMinValue()
|
| GetTipResolution(...)
| GetTipResolution(self) -> int
| C++: virtual int GetTipResolution()
|
| GetTipResolutionMaxValue(...)
| GetTipResolutionMaxValue(self) -> int
| C++: virtual int GetTipResolutionMaxValue()
|
| GetTipResolutionMinValue(...)
| GetTipResolutionMinValue(self) -> int
| C++: virtual int GetTipResolutionMinValue()
|
| InvertOff(...)
| InvertOff(self) -> None
| C++: virtual void InvertOff()
|
| InvertOn(...)
| InvertOn(self) -> None
| C++: virtual void InvertOn()
|
| Inverts the arrow direction. When set to true, base is at (1, 0,
| 0) while the tip is at (0, 0, 0). The default is false, i.e. base
| at (0, 0, 0) and the tip at (1, 0, 0).
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkArrowSource
| C++: vtkArrowSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkArrowSource
| C++: static vtkArrowSource *SafeDownCast(vtkObjectBase *o)
|
| SetArrowOrigin(...)
| SetArrowOrigin(self, _arg:ArrowOrigins) -> None
| C++: virtual void SetArrowOrigin(ArrowOrigins _arg)
|
| Sets and Gets the location used for orienting and scaling the
| arrow. Default is set to Default.
|
| SetArrowOriginToCenter(...)
| SetArrowOriginToCenter(self) -> None
| C++: void SetArrowOriginToCenter()
|
| SetArrowOriginToDefault(...)
| SetArrowOriginToDefault(self) -> None
| C++: void SetArrowOriginToDefault()
|
| SetInvert(...)
| SetInvert(self, _arg:bool) -> None
| C++: virtual void SetInvert(bool _arg)
|
| SetShaftRadius(...)
| SetShaftRadius(self, _arg:float) -> None
| C++: virtual void SetShaftRadius(double _arg)
|
| Set the radius of the shaft. Defaults to 0.03.
|
| SetShaftResolution(...)
| SetShaftResolution(self, _arg:int) -> None
| C++: virtual void SetShaftResolution(int _arg)
|
| Set the resolution of the shaft. Minimum is 3 for a triangular
| shaft.
|
| SetTipLength(...)
| SetTipLength(self, _arg:float) -> None
| C++: virtual void SetTipLength(double _arg)
|
| Set the length, and radius of the tip. They default to 0.35 and
| 0.1
|
| SetTipRadius(...)
| SetTipRadius(self, _arg:float) -> None
| C++: virtual void SetTipRadius(double _arg)
|
| SetTipResolution(...)
| SetTipResolution(self, _arg:int) -> None
| C++: virtual void SetTipResolution(int _arg)
|
| Set the resolution of the tip. The tip behaves the same as a
| cone. Resolution 1 gives a single triangle, 2 gives two crossed
| triangles.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkArrowSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkArrowSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkArrowSource:
|
| __this__
| Pointer to the C++ object.
|
| arrow_origin
| read-write, calls GetArrowOrigin/SetArrowOrigin
|
| invert
| read-write, calls GetInvert/SetInvert
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkArrowSource:
|
| ArrowOrigins = <class 'vtkmodules.vtkFiltersSources.vtkArrowSource.Arr...
|
| __vtkname__ = 'vtkArrowSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class AxesGeometrySource(pyvista.core.utilities.misc._NoNewAttrMixin)
| AxesGeometrySource(*args, **kwargs) -> '_T'
|
| Create axes geometry source.
|
| Source for generating fully 3-dimensional axes shaft and tip geometry.
|
| By default, the shafts are cylinders and the tips are cones, though other geometries
| such as spheres and cubes are also supported. The use of an arbitrary dataset
| for the shafts and/or tips is also supported.
|
| Unlike :class:`pyvista.AxesActor`, the output from this source is a
| :class:`pyvista.MultiBlock`, not an actor, and does not support colors or labels.
| The generated axes are "true-to-scale" by default, i.e. a shaft with a
| radius of 0.1 will truly have a radius of 0.1, and the axes may be oriented
| arbitrarily in space (this is not the case for :class:`pyvista.AxesActor`).
|
| Parameters
| ----------
| shaft_type : str | pyvista.DataSet, default: 'cylinder'
| Shaft type for all axes. Can be any of the following:
|
| - ``'cylinder'``
| - ``'sphere'``
| - ``'hemisphere'``
| - ``'cone'``
| - ``'pyramid'``
| - ``'cube'``
| - ``'octahedron'``
|
| Alternatively, any arbitrary 3-dimensional :class:`pyvista.DataSet` may be
| specified. In this case, the dataset must be oriented such that it "points" in
| the positive z direction.
|
| shaft_radius : float | VectorLike[float], default: 0.025
| Radius of the axes shafts.
|
| shaft_length : float | VectorLike[float], default: 0.8
| Length of the shaft for each axis.
|
| tip_type : str | pyvista.DataSet, default: 'cone'
| Tip type for all axes. Can be any of the following:
|
| - ``'cylinder'``
| - ``'sphere'``
| - ``'hemisphere'``
| - ``'cone'``
| - ``'pyramid'``
| - ``'cube'``
| - ``'octahedron'``
|
| Alternatively, any arbitrary 3-dimensional :class:`pyvista.DataSet` may be
| specified. In this case, the dataset must be oriented such that it "points" in
| the positive z direction.
|
| tip_radius : float | VectorLike[float], default: 0.1
| Radius of the axes tips.
|
| tip_length : float | VectorLike[float], default: 0.2
| Length of the tip for each axis.
|
| symmetric : bool, default: False
| Mirror the axes such that they extend to negative values.
|
| symmetric_bounds : bool, default: False
| Make the bounds of the axes symmetric. This option is similar to
| :attr:`symmetric`, except only the bounds are made to be symmetric,
| not the actual geometry. Has no effect if :attr:`symmetric` is ``True``.
|
| Method resolution order:
| AxesGeometrySource
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'AxesGeometrySource', *, shaft_type: 'GeometryTypes | DataSet' = 'cylinder', shaft_radius: 'float | VectorLike[float]' = 0.025, shaft_length: 'float | VectorLike[float]' = 0.8, tip_type: 'GeometryTypes | DataSet' = 'cone', tip_radius: 'float | VectorLike[float]' = 0.1, tip_length: 'float | VectorLike[float]' = 0.2, symmetric: 'bool' = False, symmetric_bounds: 'bool' = False) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self: 'AxesGeometrySource') -> 'str'
| Representation of the axes.
|
| update(self: 'AxesGeometrySource') -> 'None'
| Update the output of the source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output of the source.
|
| The output is a :class:`pyvista.MultiBlock` with six blocks: one for each part
| of the axes. The blocks are ordered by shafts first then tips, and in x-y-z order.
| Specifically, they are named as follows:
|
| (``'x_shaft'``, ``'y_shaft'``, ``'z_shaft'``, ``'x_tip'``, ``'y_tip'``, ``'z_tip'``)
|
| The source is automatically updated by :meth:`update` prior to returning
| the output.
|
| Returns
| -------
| pyvista.MultiBlock
| Composite mesh with separate shaft and tip datasets.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| shaft_length
| Length of the shaft for each axis.
|
| Value must be non-negative.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> axes_geometry_source = pv.AxesGeometrySource()
| >>> axes_geometry_source.shaft_length
| (0.8, 0.8, 0.8)
| >>> axes_geometry_source.shaft_length = 0.7
| >>> axes_geometry_source.shaft_length
| (0.7, 0.7, 0.7)
| >>> axes_geometry_source.shaft_length = (1.0, 0.9, 0.5)
| >>> axes_geometry_source.shaft_length
| (1.0, 0.9, 0.5)
|
| shaft_radius
| Radius of the axes shafts.
|
| Value must be non-negative.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> axes_geometry_source = pv.AxesGeometrySource()
| >>> axes_geometry_source.shaft_radius
| (0.025, 0.025, 0.025)
| >>> axes_geometry_source.shaft_radius = 0.05
| >>> axes_geometry_source.shaft_radius
| (0.05, 0.05, 0.05)
|
| shaft_type
| Shaft type for all axes.
|
| Must be a string, e.g. ``'cylinder'`` or ``'cube'`` or any other supported
| geometry. Alternatively, any arbitrary 3-dimensional :class:`pyvista.DataSet`
| may also be specified. In this case, the dataset must be oriented such that it
| "points" in the positive z direction.
|
| Examples
| --------
| Show a list of all shaft type options.
|
| >>> import pyvista as pv
| >>> pv.AxesGeometrySource.GEOMETRY_TYPES
| ('cylinder', 'sphere', 'hemisphere', 'cone', 'pyramid', 'cube', 'octahedron')
|
| Show the default shaft type and modify it.
|
| >>> axes_geometry_source = pv.AxesGeometrySource()
| >>> axes_geometry_source.shaft_type
| 'cylinder'
| >>> axes_geometry_source.shaft_type = 'cube'
| >>> axes_geometry_source.shaft_type
| 'cube'
|
| Set the shaft type to any 3-dimensional dataset.
|
| >>> axes_geometry_source.shaft_type = pv.Superquadric()
| >>> axes_geometry_source.shaft_type
| 'custom'
|
| symmetric
| Mirror the axes such that they extend to negative values.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> axes_geometry_source = pv.AxesGeometrySource(symmetric=True)
| >>> axes_geometry_source.output.plot()
|
| symmetric_bounds
| Enable or disable symmetry in the axes bounds.
|
| This option is similar to :attr:`~pyvista.AxesGeometrySource.symmetric`, except instead
| of making the axes parts symmetric, only the bounds of the axes are made to be
| symmetric. This is achieved by adding a single invisible cell to each tip
| dataset along each axis to simulate the symmetry. Setting this
| parameter primarily affects camera positioning and is useful if the
| axes are used as a widget, as it allows for the axes to rotate
| about its origin.
|
| Examples
| --------
| Get the symmetric bounds of the axes.
|
| >>> import pyvista as pv
| >>> axes_geometry_source = pv.AxesGeometrySource(symmetric_bounds=True)
| >>> axes_geometry_source.output.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 1.0,
| y_min = -1.0,
| y_max = 1.0,
| z_min = -1.0,
| z_max = 1.0)
|
| >>> axes_geometry_source.output.center
| (0.0, 0.0, 0.0)
|
| Get the asymmetric bounds.
|
| >>> axes_geometry_source.symmetric_bounds = False
| >>> axes_geometry_source.output.bounds
| BoundsTuple(x_min = -0.1,
| x_max = 1.0,
| y_min = -0.1,
| y_max = 1.0,
| z_min = -0.1,
| z_max = 1.0)
|
| >>> axes_geometry_source.output.center
| (0.45, 0.45, 0.45)
|
| Show the difference in camera positioning with and without
| symmetric bounds. Orientation is added for visualization.
|
| Create actors.
|
| >>> axes_sym = pv.AxesAssembly(orientation=(90, 0, 0), symmetric_bounds=True)
| >>> axes_asym = pv.AxesAssembly(orientation=(90, 0, 0), symmetric_bounds=False)
|
| Show multi-window plot.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_text('Symmetric bounds')
| >>> _ = pl.add_actor(axes_sym)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Asymmetric bounds')
| >>> _ = pl.add_actor(axes_asym)
| >>> pl.show()
|
| tip_length
| Length of the tip for each axis.
|
| Value must be non-negative.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> axes_geometry_source = pv.AxesGeometrySource()
| >>> axes_geometry_source.tip_length
| (0.2, 0.2, 0.2)
| >>> axes_geometry_source.tip_length = 0.3
| >>> axes_geometry_source.tip_length
| (0.3, 0.3, 0.3)
| >>> axes_geometry_source.tip_length = (0.1, 0.4, 0.2)
| >>> axes_geometry_source.tip_length
| (0.1, 0.4, 0.2)
|
| tip_radius
| Radius of the axes tips.
|
| Value must be non-negative.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> axes_geometry_source = pv.AxesGeometrySource()
| >>> axes_geometry_source.tip_radius
| (0.1, 0.1, 0.1)
| >>> axes_geometry_source.tip_radius = 0.2
| >>> axes_geometry_source.tip_radius
| (0.2, 0.2, 0.2)
|
| tip_type
| Tip type for all axes.
|
| Must be a string, e.g. ``'cone'`` or ``'sphere'`` or any other supported
| geometry. Alternatively, any arbitrary 3-dimensional :class:`pyvista.DataSet`
| may also be specified. In this case, the dataset must be oriented such that it
| "points" in the positive z direction.
|
| Examples
| --------
| Show a list of all shaft type options.
|
| >>> import pyvista as pv
| >>> pv.AxesGeometrySource.GEOMETRY_TYPES
| ('cylinder', 'sphere', 'hemisphere', 'cone', 'pyramid', 'cube', 'octahedron')
|
| Show the default tip type and modify it.
|
| >>> axes_geometry_source = pv.AxesGeometrySource()
| >>> axes_geometry_source.tip_type
| 'cone'
| >>> axes_geometry_source.tip_type = 'sphere'
| >>> axes_geometry_source.tip_type
| 'sphere'
|
| Set the tip type to any 3-dimensional dataset.
|
| >>> axes_geometry_source.tip_type = pv.Text3D('O')
| >>> axes_geometry_source.tip_type
| 'custom'
|
| >>> axes_geometry_source.output.plot(cpos='xy')
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| GEOMETRY_TYPES = ('cylinder', 'sphere', 'hemisphere', 'cone', 'pyramid...
|
| GeometryTypes = typing.Literal['cylinder', 'sphere', 'hemisphere', 'co...
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'GEOMETRY_TYPES': 'ClassVar[tuple[str]]'}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class BoxSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource)
| BoxSource(*args, **kwargs) -> '_T'
|
| Create a box source.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| bounds : sequence[float], default: (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0)
| Specify the bounds of the box.
| ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| level : int, default: 0
| Level of subdivision of the faces.
|
| quads : bool, default: True
| Flag to tell the source to generate either a quad or two
| triangle for a set of four points.
|
| Method resolution order:
| BoxSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'BoxSource', bounds: 'VectorLike[float]' = (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0), level: 'int' = 0, quads: 'bool' = True) -> 'None'
| Initialize source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Plane mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| bounds
| Return or set the bounds of the box.
|
| level
| Get level of subdivision of the faces.
|
| Returns
| -------
| int
| Level of subdivision of the faces.
|
| quads
| Flag to tell the source to generate a quad or two triangle for a set of four points.
|
| Returns
| -------
| bool
| Flag to tell the source to generate either a quad or two
| triangle for a set of four points.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource:
|
| DuplicateSharedPointsOff(...)
| DuplicateSharedPointsOff(self) -> None
| C++: virtual void DuplicateSharedPointsOff()
|
| DuplicateSharedPointsOn(...)
| DuplicateSharedPointsOn(self) -> None
| C++: virtual void DuplicateSharedPointsOn()
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: virtual double *GetBounds()
|
| Bounds of the box in world coordinates. This a 6-uple of
| xmin,xmax,ymin, ymax,zmin and zmax. Initial value is
| (-0.5,0.5,-0.5,0.5,-0.5,0.5), bounds of a cube of length 1
| centered at (0,0,0). Bounds are defined such that xmin<=xmax,
| ymin<=ymax and zmin<zmax.
| \post xmin<=xmax && ymin<=ymax && zmin<zmax
|
| GetDuplicateSharedPoints(...)
| GetDuplicateSharedPoints(self) -> int
| C++: virtual vtkTypeBool GetDuplicateSharedPoints()
|
| GetLevel(...)
| GetLevel(self) -> int
| C++: virtual int GetLevel()
|
| Level of subdivision of the faces. Initial value is 0.
| \post positive_level: level>=0
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetQuads(...)
| GetQuads(self) -> int
| C++: virtual vtkTypeBool GetQuads()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkTessellatedBoxSource
| C++: vtkTessellatedBoxSource *NewInstance()
|
| QuadsOff(...)
| QuadsOff(self) -> None
| C++: virtual void QuadsOff()
|
| QuadsOn(...)
| QuadsOn(self) -> None
| C++: virtual void QuadsOn()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkTessellatedBoxSource
| C++: static vtkTessellatedBoxSource *SafeDownCast(
| vtkObjectBase *o)
|
| SetBounds(...)
| SetBounds(self, _arg1:float, _arg2:float, _arg3:float,
| _arg4:float, _arg5:float, _arg6:float) -> None
| C++: virtual void SetBounds(double _arg1, double _arg2,
| double _arg3, double _arg4, double _arg5, double _arg6)
| SetBounds(self, _arg:(float, float, float, float, float, float))
| -> None
| C++: virtual void SetBounds(const double _arg[6])
|
| Set the bounds of the box. See GetBounds() for a detail
| description.
| \pre xmin<=xmax && ymin<=ymax && zmin<zmax
|
| SetDuplicateSharedPoints(...)
| SetDuplicateSharedPoints(self, _arg:int) -> None
| C++: virtual void SetDuplicateSharedPoints(vtkTypeBool _arg)
|
| Flag to tell the source to duplicate points shared between faces
| (vertices of the box and internal edge points). Initial value is
| false. Implementation note: duplicating points is an easier
| method to implement than a minimal number of points.
|
| SetLevel(...)
| SetLevel(self, _arg:int) -> None
| C++: virtual void SetLevel(int _arg)
|
| Set the level of subdivision of the faces.
| \pre positive_level: level>=0
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetQuads(...)
| SetQuads(self, _arg:int) -> None
| C++: virtual void SetQuads(vtkTypeBool _arg)
|
| Flag to tell the source to generate either a quad or two triangle
| for a set of four points. Initial value is false (generate
| triangles).
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource:
|
| __this__
| Pointer to the C++ object.
|
| duplicate_shared_points
| read-write, calls GetDuplicateSharedPoints/SetDuplicateSharedPoints
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkTessellatedBoxSource:
|
| __vtkname__ = 'vtkTessellatedBoxSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class ConeSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkConeSource)
| ConeSource(*args, **kwargs) -> '_T'
|
| Cone source algorithm class.
|
| Parameters
| ----------
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Center in ``[x, y, z]``. Axis of the cone passes through this
| point.
|
| direction : sequence[float], default: (1.0, 0.0, 0.0)
| Direction vector in ``[x, y, z]``. Orientation vector of the
| cone.
|
| height : float, default: 1.0
| Height along the cone in its specified direction.
|
| radius : float, optional
| Base radius of the cone.
|
| capping : bool, default: True
| Enable or disable the capping the base of the cone with a
| polygon.
|
| angle : float, optional
| The angle in degrees between the axis of the cone and a
| generatrix.
|
| resolution : int, default: 6
| Number of facets used to represent the cone.
|
| Examples
| --------
| Create a default ConeSource.
|
| >>> import pyvista as pv
| >>> source = pv.ConeSource()
| >>> source.output.plot(show_edges=True, line_width=5)
|
| Method resolution order:
| ConeSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkConeSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'ConeSource', center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0), height: 'float' = 1.0, radius: 'float | None' = None, capping: 'bool' = True, angle: 'float | None' = None, resolution: 'int' = 6) -> 'None'
| Initialize the cone source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Cone surface.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| angle
| Get the angle in degrees between the axis of the cone and a generatrix.
|
| Returns
| -------
| float
| The angle in degrees between the axis of the cone and a
| generatrix.
|
| capping
| Enable or disable the capping the base of the cone with a polygon.
|
| Returns
| -------
| bool
| Enable or disable the capping the base of the cone with a
| polygon.
|
| center
| Get the center in ``[x, y, z]``. Axis of the cone passes through this point.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``. Axis of the cone passes through this
| point.
|
| direction
| Get the direction vector in ``[x, y, z]``. Orientation vector of the cone.
|
| Returns
| -------
| sequence[float]
| Direction vector in ``[x, y, z]``. Orientation vector of the
| cone.
|
| height
| Get the height along the cone in its specified direction.
|
| Returns
| -------
| float
| Height along the cone in its specified direction.
|
| radius
| Get base radius of the cone.
|
| Returns
| -------
| float
| Base radius of the cone.
|
| resolution
| Get number of points on the circular face of the cone.
|
| Returns
| -------
| int
| Number of points on the circular face of the cone.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkConeSource:
|
| CappingOff(...)
| CappingOff(self) -> None
| C++: virtual void CappingOff()
|
| CappingOn(...)
| CappingOn(self) -> None
| C++: virtual void CappingOn()
|
| GetAngle(...)
| GetAngle(self) -> float
| C++: double GetAngle()
|
| GetCapping(...)
| GetCapping(self) -> int
| C++: virtual vtkTypeBool GetCapping()
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetDirection(...)
| GetDirection(self) -> (float, float, float)
| C++: virtual double *GetDirection()
|
| GetHeight(...)
| GetHeight(self) -> float
| C++: virtual double GetHeight()
|
| GetHeightMaxValue(...)
| GetHeightMaxValue(self) -> float
| C++: virtual double GetHeightMaxValue()
|
| GetHeightMinValue(...)
| GetHeightMinValue(self) -> float
| C++: virtual double GetHeightMinValue()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetRadius(...)
| GetRadius(self) -> float
| C++: virtual double GetRadius()
|
| GetRadiusMaxValue(...)
| GetRadiusMaxValue(self) -> float
| C++: virtual double GetRadiusMaxValue()
|
| GetRadiusMinValue(...)
| GetRadiusMinValue(self) -> float
| C++: virtual double GetRadiusMinValue()
|
| GetResolution(...)
| GetResolution(self) -> int
| C++: virtual int GetResolution()
|
| GetResolutionMaxValue(...)
| GetResolutionMaxValue(self) -> int
| C++: virtual int GetResolutionMaxValue()
|
| GetResolutionMinValue(...)
| GetResolutionMinValue(self) -> int
| C++: virtual int GetResolutionMinValue()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkConeSource
| C++: vtkConeSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkConeSource
| C++: static vtkConeSource *SafeDownCast(vtkObjectBase *o)
|
| SetAngle(...)
| SetAngle(self, angle:float) -> None
| C++: void SetAngle(double angle)
|
| Set the angle of the cone. This is the angle between the axis of
| the cone and a generatrix. Warning: this is not the aperture! The
| aperture is twice this angle. As a side effect, the angle plus
| height sets the base radius of the cone. Angle is expressed in
| degrees.
|
| SetCapping(...)
| SetCapping(self, _arg:int) -> None
| C++: virtual void SetCapping(vtkTypeBool _arg)
|
| Turn on/off whether to cap the base of the cone with a polygon.
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set the center of the cone. It is located at the middle of the
| axis of the cone. Warning: this is not the center of the base of
| the cone! The default is 0,0,0.
|
| SetDirection(...)
| SetDirection(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetDirection(double _arg1, double _arg2,
| double _arg3)
| SetDirection(self, _arg:(float, float, float)) -> None
| C++: virtual void SetDirection(const double _arg[3])
|
| Set the orientation vector of the cone. The vector does not have
| to be normalized. The direction goes from the center of the base
| toward the apex. The default is (1,0,0).
|
| SetHeight(...)
| SetHeight(self, _arg:float) -> None
| C++: virtual void SetHeight(double _arg)
|
| Set the height of the cone. This is the height along the cone in
| its specified direction.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetRadius(...)
| SetRadius(self, _arg:float) -> None
| C++: virtual void SetRadius(double _arg)
|
| Set the base radius of the cone.
|
| SetResolution(...)
| SetResolution(self, _arg:int) -> None
| C++: virtual void SetResolution(int _arg)
|
| Set the number of facets used to represent the cone.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkConeSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkConeSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkConeSource:
|
| __this__
| Pointer to the C++ object.
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkConeSource:
|
| __vtkname__ = 'vtkConeSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class CubeFacesSource(CubeSource)
| CubeFacesSource(*args, **kwargs) -> '_T'
|
| Generate the faces of a cube.
|
| This source generates a :class:`~pyvista.MultiBlock` with the six :class:`PolyData`
| comprising the faces of a cube.
|
| The faces may be shrunk or exploded to create equal-sized gaps or intersections
| between the faces. Additionally, the faces may be converted to frames with a
| constant-width border.
|
| .. versionadded:: 0.45.0
|
| Parameters
| ----------
| center : VectorLike[float], default: (0.0, 0.0, 0.0)
| Center in ``[x, y, z]``.
|
| x_length : float, default: 1.0
| Length of the cube in the x-direction.
|
| y_length : float, default: 1.0
| Length of the cube in the y-direction.
|
| z_length : float, default: 1.0
| Length of the cube in the z-direction.
|
| bounds : sequence[float], optional
| Specify the bounding box of the cube. If given, all other size
| arguments are ignored. ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| frame_width : float, optional
| Convert the faces into frames with the specified width. If set, the center
| portion of each face is removed and the output faces will each have four quad
| cells (one for each side of the frame) instead of a single quad cell. Values
| must be between ``0.0`` (minimal frame) and ``1.0`` (large frame). The frame is
| scaled to ensure it has a constant width.
|
| shrink_factor : float, optional
| Shrink or grow the cube's faces. If set, this is the factor by which to shrink
| or grow each face. The amount of shrinking or growth is relative to the smallest
| edge length of the cube, and all sides of the faces are shrunk by the same
| (constant) value.
|
| .. note::
| - A value of ``1.0`` has no effect.
| - Values between ``0.0`` and ``1.0`` will shrink the faces.
| - Values greater than ``1.0`` will grow the faces.
|
| This has a similar effect to using :meth:`~pyvista.DataSetFilters.shrink`.
|
| explode_factor : float, optional
| Push the faces away from (or pull them toward) the cube's center. If set, this
| is the factor by which to move each face. The magnitude of the move is relative
| to the smallest edge length of the cube, and all faces are moved by the same
| (constant) amount.
|
| .. note::
| - A value of ``0.0`` has no effect.
| - Increasing positive values will push the faces farther away (explode).
| - Decreasing negative values will pull the faces closer together (implode).
|
| This has a similar effect to using :meth:`~pyvista.DataSetFilters.explode`.
|
| names : sequence[str], default: ('+X','-X','+Y','-Y','+Z','-Z')
| Name of each face in the generated :class:`~pyvista.MultiBlock`.
|
| point_dtype : str, default: 'float32'
| Set the desired output point types. It must be either 'float32' or 'float64'.
|
| Examples
| --------
| Generate the default faces of a cube.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> cube_faces_source = pv.CubeFacesSource()
| >>> output = cube_faces_source.output
| >>> output.plot(show_edges=True, line_width=10)
|
| The output is similar to that of :class:`CubeSource` except it's a
| :class:`~pyvista.MultiBlock`.
|
| >>> output
| MultiBlock (...)
| N Blocks: 6
| X Bounds: -5.000e-01, 5.000e-01
| Y Bounds: -5.000e-01, 5.000e-01
| Z Bounds: -5.000e-01, 5.000e-01
|
| >>> cube_source = pv.CubeSource()
| >>> cube_source.output
| PolyData (...)
| N Cells: 6
| N Points: 24
| N Strips: 0
| X Bounds: -5.000e-01, 5.000e-01
| Y Bounds: -5.000e-01, 5.000e-01
| Z Bounds: -5.000e-01, 5.000e-01
| N Arrays: 2
|
| Use :attr:`explode_factor` to explode the faces.
|
| >>> cube_faces_source.explode_factor = 0.5
| >>> cube_faces_source.update()
| >>> output.plot(show_edges=True, line_width=10)
|
| Use :attr:`shrink_factor` to also shrink the faces.
|
| >>> cube_faces_source.shrink_factor = 0.5
| >>> cube_faces_source.update()
| >>> output.plot(show_edges=True, line_width=10)
|
| Fit cube faces to a dataset and only plot four of them.
|
| >>> mesh = examples.load_airplane()
| >>> cube_faces_source = pv.CubeFacesSource(bounds=mesh.bounds)
| >>> output = cube_faces_source.output
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='tomato')
| >>> _ = pl.add_mesh(output['+X'], opacity=0.5)
| >>> _ = pl.add_mesh(output['-X'], opacity=0.5)
| >>> _ = pl.add_mesh(output['+Y'], opacity=0.5)
| >>> _ = pl.add_mesh(output['-Y'], opacity=0.5)
| >>> pl.show()
|
| Generate a frame instead of full faces.
|
| >>> mesh = pv.ParametricEllipsoid(5, 4, 3)
| >>> cube_faces_source = pv.CubeFacesSource(bounds=mesh.bounds, frame_width=0.1)
| >>> output = cube_faces_source.output
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='tomato')
| >>> _ = pl.add_mesh(output, show_edges=True, line_width=10)
| >>> pl.show()
|
| Method resolution order:
| CubeFacesSource
| CubeSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkCubeSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'CubeFacesSource', *, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), x_length: 'float' = 1.0, y_length: 'float' = 1.0, z_length: 'float' = 1.0, bounds: 'VectorLike[float] | None' = None, frame_width: 'float | None' = None, shrink_factor: 'float | None' = None, explode_factor: 'float | None' = None, names: 'Sequence[str]' = ('+X', '-X', '+Y', '-Y', '+Z', '-Z'), point_dtype: 'str' = 'float32') -> 'None'
| Initialize the cube source class.
|
| update(self: 'CubeFacesSource') -> 'None'
| Update the output of the source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output of the source.
|
| The output is a :class:`pyvista.MultiBlock` with six blocks: one for each
| face. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The source is automatically updated by :meth:`update` prior to returning
| the output.
|
| Returns
| -------
| pyvista.MultiBlock
| Composite mesh with six cube faces.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| explode_factor
| Push the faces away from (or pull them toward) the cube's center.
|
| If set, this is the factor by which to move each face. The magnitude of the
| move is relative to the smallest edge length of the cube, and all faces are
| moved by the same (constant) amount.
|
| .. note::
| - A value of ``0.0`` has no effect.
| - Increasing positive values will push the faces farther away (explode).
| - Decreasing negative values will pull the faces closer together (implode).
|
| This has a similar effect to using :meth:`~pyvista.DataSetFilters.explode`.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> cube_faces_source = pv.CubeFacesSource(
| ... x_length=3, y_length=2, z_length=1, explode_factor=0.2
| ... )
| >>> output = cube_faces_source.output
| >>> output.plot(show_edges=True, line_width=10)
|
| Note how all faces are moved by the same amount. Compare this to using
| :meth:`~pyvista.DataSetFilters.explode` where the distance each face moves
| is relative to distance of each face to the center of the cube.
|
| >>> exploded = pv.merge(output).explode(0.2)
| >>> exploded.plot(show_edges=True, line_width=10)
|
| frame_width
| Convert the faces into frames with the specified border width.
|
| If set, the center portion of each face is removed and the :attr:`output`
| :class:`pyvista.PolyData` will each have four quad cells (one for each
| side of the frame) instead of a single quad cell. Values must be between ``0.0``
| (minimal frame) and ``1.0`` (large frame). The frame is scaled to ensure it has
| a constant width.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> cube_faces_source = pv.CubeFacesSource(
| ... x_length=3, y_length=2, z_length=1, frame_width=0.2
| ... )
| >>> cube_faces_source.output.plot(show_edges=True, line_width=10)
|
| >>> cube_faces_source.frame_width = 0.8
| >>> cube_faces_source.output.plot(show_edges=True, line_width=10)
|
| names
| Return or set the names of the faces.
|
| Specify three strings, one for each '+/-' face pair, or six strings, one for
| each individual face.
|
| If three strings, plus ``'+'`` and minus ``'-'`` characters are added to
| the names.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> cube_faces = pv.CubeFacesSource()
|
| Use three strings to set the names. Plus ``'+'`` and minus ``'-'``
| characters are added automatically.
|
| >>> cube_faces.names = ['U', 'V', 'W']
| >>> cube_faces.names
| ('+U', '-U', '+V', '-V', '+W', '-W')
|
| Alternatively, use six strings to set the names explicitly.
|
| >>> cube_faces.names = [
| ... 'right',
| ... 'left',
| ... 'anterior',
| ... 'posterior',
| ... 'superior',
| ... 'inferior',
| ... ]
| >>> cube_faces.names
| ('right', 'left', 'anterior', 'posterior', 'superior', 'inferior')
|
| shrink_factor
| Shrink or grow the cube's faces.
|
| If set, this is the factor by which to shrink or grow each face. The amount of
| shrinking or growth is relative to the smallest edge length of the cube, and
| all sides of the faces are shrunk by the same (constant) value.
|
| .. note::
| - A value of ``1.0`` has no effect.
| - Values between ``0.0`` and ``1.0`` will shrink the faces.
| - Values greater than ``1.0`` will grow the faces.
|
| This has a similar effect to using :meth:`~pyvista.DataSetFilters.shrink`.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> cube_faces_source = pv.CubeFacesSource(
| ... x_length=3, y_length=2, z_length=1, shrink_factor=0.8
| ... )
| >>> output = cube_faces_source.output
| >>> output.plot(show_edges=True, line_width=10)
|
| Note how all edges are shrunk by the same (constant) amount in terms of absolute
| distance. Compare this to :meth:`~pyvista.DataSetFilters.shrink` where the
| amount of shrinkage is relative to the size of the faces.
|
| >>> exploded = pv.merge(output).shrink(0.8)
| >>> exploded.plot(show_edges=True, line_width=10)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from CubeSource:
|
| bounds
| Return or set the bounding box of the cube.
|
| center
| Get the center in ``[x, y, z]``.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``.
|
| point_dtype
| Get the desired output point types.
|
| Returns
| -------
| str
| Desired output point types.
| It must be either 'float32' or 'float64'.
|
| x_length
| Get the x length along the cube in its specified direction.
|
| Returns
| -------
| float
| XLength along the cone in its specified direction.
|
| y_length
| Get the y length along the cube in its specified direction.
|
| Returns
| -------
| float
| YLength along the cone in its specified direction.
|
| z_length
| Get the z length along the cube in its specified direction.
|
| Returns
| -------
| float
| ZLength along the cone in its specified direction.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| GetBounds(...)
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetXLength(...)
| GetXLength(self) -> float
| C++: virtual double GetXLength()
|
| GetXLengthMaxValue(...)
| GetXLengthMaxValue(self) -> float
| C++: virtual double GetXLengthMaxValue()
|
| GetXLengthMinValue(...)
| GetXLengthMinValue(self) -> float
| C++: virtual double GetXLengthMinValue()
|
| GetYLength(...)
| GetYLength(self) -> float
| C++: virtual double GetYLength()
|
| GetYLengthMaxValue(...)
| GetYLengthMaxValue(self) -> float
| C++: virtual double GetYLengthMaxValue()
|
| GetYLengthMinValue(...)
| GetYLengthMinValue(self) -> float
| C++: virtual double GetYLengthMinValue()
|
| GetZLength(...)
| GetZLength(self) -> float
| C++: virtual double GetZLength()
|
| GetZLengthMaxValue(...)
| GetZLengthMaxValue(self) -> float
| C++: virtual double GetZLengthMaxValue()
|
| GetZLengthMinValue(...)
| GetZLengthMinValue(self) -> float
| C++: virtual double GetZLengthMinValue()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkCubeSource
| C++: vtkCubeSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkCubeSource
| C++: static vtkCubeSource *SafeDownCast(vtkObjectBase *o)
|
| SetBounds(...)
| SetBounds(self, xMin:float, xMax:float, yMin:float, yMax:float,
| zMin:float, zMax:float) -> None
| C++: void SetBounds(double xMin, double xMax, double yMin,
| double yMax, double zMin, double zMax)
| SetBounds(self, bounds:(float, float, float, float, float, float))
| -> None
| C++: void SetBounds(const double bounds[6])
|
| Convenience methods allows creation of cube by specifying
| bounding box.
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set the center of the cube.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetXLength(...)
| SetXLength(self, _arg:float) -> None
| C++: virtual void SetXLength(double _arg)
|
| Set the length of the cube in the x-direction.
|
| SetYLength(...)
| SetYLength(self, _arg:float) -> None
| C++: virtual void SetYLength(double _arg)
|
| Set the length of the cube in the y-direction.
|
| SetZLength(...)
| SetZLength(self, _arg:float) -> None
| C++: virtual void SetZLength(double _arg)
|
| Set the length of the cube in the z-direction.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkCubeSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| __this__
| Pointer to the C++ object.
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| __vtkname__ = 'vtkCubeSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class CubeSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkCubeSource)
| CubeSource(*args, **kwargs) -> '_T'
|
| Cube source algorithm class.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Center in ``[x, y, z]``.
|
| x_length : float, default: 1.0
| Length of the cube in the x-direction.
|
| y_length : float, default: 1.0
| Length of the cube in the y-direction.
|
| z_length : float, default: 1.0
| Length of the cube in the z-direction.
|
| bounds : sequence[float], optional
| Specify the bounding box of the cube. If given, all other size
| arguments are ignored. ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| point_dtype : str, default: 'float32'
| Set the desired output point types. It must be either 'float32' or 'float64'.
|
| .. versionadded:: 0.44.0
|
| Examples
| --------
| Create a default CubeSource.
|
| >>> import pyvista as pv
| >>> source = pv.CubeSource()
| >>> source.output.plot(show_edges=True, line_width=5)
|
| Method resolution order:
| CubeSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkCubeSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'CubeSource', center: 'VectorLike[float]' = (0.0, 0.0, 0.0), x_length: 'float' = 1.0, y_length: 'float' = 1.0, z_length: 'float' = 1.0, bounds: 'VectorLike[float] | None' = None, point_dtype: 'str' = 'float32') -> 'None'
| Initialize the cube source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Cube surface.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| bounds
| Return or set the bounding box of the cube.
|
| center
| Get the center in ``[x, y, z]``.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``.
|
| point_dtype
| Get the desired output point types.
|
| Returns
| -------
| str
| Desired output point types.
| It must be either 'float32' or 'float64'.
|
| x_length
| Get the x length along the cube in its specified direction.
|
| Returns
| -------
| float
| XLength along the cone in its specified direction.
|
| y_length
| Get the y length along the cube in its specified direction.
|
| Returns
| -------
| float
| YLength along the cone in its specified direction.
|
| z_length
| Get the z length along the cube in its specified direction.
|
| Returns
| -------
| float
| ZLength along the cone in its specified direction.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| GetBounds(...)
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetXLength(...)
| GetXLength(self) -> float
| C++: virtual double GetXLength()
|
| GetXLengthMaxValue(...)
| GetXLengthMaxValue(self) -> float
| C++: virtual double GetXLengthMaxValue()
|
| GetXLengthMinValue(...)
| GetXLengthMinValue(self) -> float
| C++: virtual double GetXLengthMinValue()
|
| GetYLength(...)
| GetYLength(self) -> float
| C++: virtual double GetYLength()
|
| GetYLengthMaxValue(...)
| GetYLengthMaxValue(self) -> float
| C++: virtual double GetYLengthMaxValue()
|
| GetYLengthMinValue(...)
| GetYLengthMinValue(self) -> float
| C++: virtual double GetYLengthMinValue()
|
| GetZLength(...)
| GetZLength(self) -> float
| C++: virtual double GetZLength()
|
| GetZLengthMaxValue(...)
| GetZLengthMaxValue(self) -> float
| C++: virtual double GetZLengthMaxValue()
|
| GetZLengthMinValue(...)
| GetZLengthMinValue(self) -> float
| C++: virtual double GetZLengthMinValue()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkCubeSource
| C++: vtkCubeSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkCubeSource
| C++: static vtkCubeSource *SafeDownCast(vtkObjectBase *o)
|
| SetBounds(...)
| SetBounds(self, xMin:float, xMax:float, yMin:float, yMax:float,
| zMin:float, zMax:float) -> None
| C++: void SetBounds(double xMin, double xMax, double yMin,
| double yMax, double zMin, double zMax)
| SetBounds(self, bounds:(float, float, float, float, float, float))
| -> None
| C++: void SetBounds(const double bounds[6])
|
| Convenience methods allows creation of cube by specifying
| bounding box.
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set the center of the cube.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetXLength(...)
| SetXLength(self, _arg:float) -> None
| C++: virtual void SetXLength(double _arg)
|
| Set the length of the cube in the x-direction.
|
| SetYLength(...)
| SetYLength(self, _arg:float) -> None
| C++: virtual void SetYLength(double _arg)
|
| Set the length of the cube in the y-direction.
|
| SetZLength(...)
| SetZLength(self, _arg:float) -> None
| C++: virtual void SetZLength(double _arg)
|
| Set the length of the cube in the z-direction.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkCubeSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| __this__
| Pointer to the C++ object.
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkCubeSource:
|
| __vtkname__ = 'vtkCubeSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class CylinderSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkCylinderSource)
| CylinderSource(*args, **kwargs) -> '_T'
|
| Cylinder source algorithm class.
|
| .. warning::
| :func:`pyvista.Cylinder` function rotates the :class:`pyvista.CylinderSource` 's
| :class:`pyvista.PolyData` in its own way.
| It rotates the :attr:`pyvista.CylinderSource.output` 90 degrees in z-axis, translates and
| orients the mesh to a new ``center`` and ``direction``.
|
| Parameters
| ----------
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Location of the centroid in ``[x, y, z]``.
|
| direction : sequence[float], default: (1.0, 0.0, 0.0)
| Direction cylinder points to in ``[x, y, z]``.
|
| radius : float, default: 0.5
| Radius of the cylinder.
|
| height : float, default: 1.0
| Height of the cylinder.
|
| capping : bool, default: True
| Cap cylinder ends with polygons.
|
| resolution : int, default: 100
| Number of points on the circular face of the cylinder.
|
| Examples
| --------
| Create a default CylinderSource.
|
| >>> import pyvista as pv
| >>> source = pv.CylinderSource()
| >>> source.output.plot(show_edges=True, line_width=5)
|
| Display a 3D plot of a default :class:`CylinderSource`.
|
| >>> import pyvista as pv
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pv.CylinderSource(), show_edges=True, line_width=5)
| >>> pl.show()
|
| Visualize the output of :class:`CylinderSource` in a 3D plot.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pv.CylinderSource().output, show_edges=True, line_width=5)
| >>> pl.show()
|
| The above examples are similar in terms of their behavior.
|
| Method resolution order:
| CylinderSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkCylinderSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'CylinderSource', center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0), radius: 'float' = 0.5, height: 'float' = 1.0, capping: 'bool' = True, resolution: 'int' = 100) -> 'None'
| Initialize the cylinder source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Cylinder surface.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| capping
| Get cap cylinder ends with polygons.
|
| Returns
| -------
| bool
| Cap cylinder ends with polygons.
|
| capsule_cap
| Get whether the capping should make the cylinder a capsule.
|
| .. versionadded:: 0.44.0
|
| Returns
| -------
| bool
| Capsule cap.
|
| center
| Get location of the centroid in ``[x, y, z]``.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``. Axis of the cylinder passes through this
| point.
|
| direction
| Get the direction vector in ``[x, y, z]``. Orientation vector of the cylinder.
|
| Returns
| -------
| sequence[float]
| Direction vector in ``[x, y, z]``. Orientation vector of the
| cylinder.
|
| height
| Get the height of the cylinder.
|
| Returns
| -------
| float
| Height of the cylinder.
|
| radius
| Get radius of the cylinder.
|
| Returns
| -------
| float
| Radius of the cylinder.
|
| resolution
| Get number of points on the circular face of the cylinder.
|
| Returns
| -------
| int
| Number of points on the circular face of the cone.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkCylinderSource:
|
| CappingOff(...)
| CappingOff(self) -> None
| C++: virtual void CappingOff()
|
| CappingOn(...)
| CappingOn(self) -> None
| C++: virtual void CappingOn()
|
| CapsuleCapOff(...)
| CapsuleCapOff(self) -> None
| C++: virtual void CapsuleCapOff()
|
| CapsuleCapOn(...)
| CapsuleCapOn(self) -> None
| C++: virtual void CapsuleCapOn()
|
| GetCapping(...)
| GetCapping(self) -> int
| C++: virtual vtkTypeBool GetCapping()
|
| GetCapsuleCap(...)
| GetCapsuleCap(self) -> int
| C++: virtual vtkTypeBool GetCapsuleCap()
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetHeight(...)
| GetHeight(self) -> float
| C++: virtual double GetHeight()
|
| GetHeightMaxValue(...)
| GetHeightMaxValue(self) -> float
| C++: virtual double GetHeightMaxValue()
|
| GetHeightMinValue(...)
| GetHeightMinValue(self) -> float
| C++: virtual double GetHeightMinValue()
|
| GetLatLongTessellation(...)
| GetLatLongTessellation(self) -> int
| C++: virtual vtkTypeBool GetLatLongTessellation()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetRadius(...)
| GetRadius(self) -> float
| C++: virtual double GetRadius()
|
| GetRadiusMaxValue(...)
| GetRadiusMaxValue(self) -> float
| C++: virtual double GetRadiusMaxValue()
|
| GetRadiusMinValue(...)
| GetRadiusMinValue(self) -> float
| C++: virtual double GetRadiusMinValue()
|
| GetResolution(...)
| GetResolution(self) -> int
| C++: virtual int GetResolution()
|
| GetResolutionMaxValue(...)
| GetResolutionMaxValue(self) -> int
| C++: virtual int GetResolutionMaxValue()
|
| GetResolutionMinValue(...)
| GetResolutionMinValue(self) -> int
| C++: virtual int GetResolutionMinValue()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| LatLongTessellationOff(...)
| LatLongTessellationOff(self) -> None
| C++: virtual void LatLongTessellationOff()
|
| LatLongTessellationOn(...)
| LatLongTessellationOn(self) -> None
| C++: virtual void LatLongTessellationOn()
|
| NewInstance(...)
| NewInstance(self) -> vtkCylinderSource
| C++: vtkCylinderSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkCylinderSource
| C++: static vtkCylinderSource *SafeDownCast(vtkObjectBase *o)
|
| SetCapping(...)
| SetCapping(self, _arg:int) -> None
| C++: virtual void SetCapping(vtkTypeBool _arg)
|
| Turn on/off whether to cap cylinder with polygons. Initial value
| is true.
|
| SetCapsuleCap(...)
| SetCapsuleCap(self, _arg:int) -> None
| C++: virtual void SetCapsuleCap(vtkTypeBool _arg)
|
| Set/Get whether the capping should make the cylinder a capsule.
| This adds hemispherical caps at the ends of the cylinder.
|
| \sa SetCapping()
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set/Get cylinder center. Initial value is (0.0,0.0,0.0)
|
| SetHeight(...)
| SetHeight(self, _arg:float) -> None
| C++: virtual void SetHeight(double _arg)
|
| Set the height of the cylinder. Initial value is 1.
|
| SetLatLongTessellation(...)
| SetLatLongTessellation(self, _arg:int) -> None
| C++: virtual void SetLatLongTessellation(vtkTypeBool _arg)
|
| Cause the spheres to be tessellated with edges along the latitude
| and longitude lines. If off, triangles are generated at non-polar
| regions, which results in edges that are not parallel to latitude
| and longitude lines. If on, quadrilaterals are generated
| everywhere except at the poles. This can be useful for generating
| wireframe spheres with natural latitude and longitude lines.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetRadius(...)
| SetRadius(self, _arg:float) -> None
| C++: virtual void SetRadius(double _arg)
|
| Set the radius of the cylinder. Initial value is 0.5
|
| SetResolution(...)
| SetResolution(self, _arg:int) -> None
| C++: virtual void SetResolution(int _arg)
|
| Set the number of facets used to define cylinder. Initial value
| is 6.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkCylinderSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkCylinderSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkCylinderSource:
|
| __this__
| Pointer to the C++ object.
|
| lat_long_tessellation
| read-write, calls GetLatLongTessellation/SetLatLongTessellation
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkCylinderSource:
|
| __vtkname__ = 'vtkCylinderSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class DiscSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkDiskSource)
| DiscSource(*args, **kwargs) -> '_T'
|
| Disc source algorithm class.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Center in ``[x, y, z]``. Middle of the axis of the disc.
|
| inner : float, default: 0.25
| The inner radius.
|
| outer : float, default: 0.5
| The outer radius.
|
| r_res : int, default: 1
| Number of points in radial direction.
|
| c_res : int, default: 6
| Number of points in circumferential direction.
|
| Examples
| --------
| Create a disc with 50 points in the circumferential direction.
|
| >>> import pyvista as pv
| >>> source = pv.DiscSource(c_res=50)
| >>> source.output.plot(show_edges=True, line_width=5)
|
| Method resolution order:
| DiscSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkDiskSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'DiscSource', center: 'VectorLike[float] | None' = None, inner: 'float' = 0.25, outer: 'float' = 0.5, r_res: 'int' = 1, c_res: 'int' = 6) -> 'None'
| Initialize the disc source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Line mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| c_res
| Get number of points in circumferential direction.
|
| Returns
| -------
| int
| Number of points in circumferential direction.
|
| center
| Get the center in ``[x, y, z]``.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``.
|
| inner
| Get the inner radius.
|
| Returns
| -------
| float
| The inner radius.
|
| outer
| Get the outer radius.
|
| Returns
| -------
| float
| The outer radius.
|
| r_res
| Get number of points in radial direction.
|
| Returns
| -------
| int
| Number of points in radial direction.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkDiskSource:
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetCircumferentialResolution(...)
| GetCircumferentialResolution(self) -> int
| C++: virtual int GetCircumferentialResolution()
|
| GetCircumferentialResolutionMaxValue(...)
| GetCircumferentialResolutionMaxValue(self) -> int
| C++: virtual int GetCircumferentialResolutionMaxValue()
|
| GetCircumferentialResolutionMinValue(...)
| GetCircumferentialResolutionMinValue(self) -> int
| C++: virtual int GetCircumferentialResolutionMinValue()
|
| GetInnerRadius(...)
| GetInnerRadius(self) -> float
| C++: virtual double GetInnerRadius()
|
| GetInnerRadiusMaxValue(...)
| GetInnerRadiusMaxValue(self) -> float
| C++: virtual double GetInnerRadiusMaxValue()
|
| GetInnerRadiusMinValue(...)
| GetInnerRadiusMinValue(self) -> float
| C++: virtual double GetInnerRadiusMinValue()
|
| GetNormal(...)
| GetNormal(self) -> (float, float, float)
| C++: virtual double *GetNormal()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOuterRadius(...)
| GetOuterRadius(self) -> float
| C++: virtual double GetOuterRadius()
|
| GetOuterRadiusMaxValue(...)
| GetOuterRadiusMaxValue(self) -> float
| C++: virtual double GetOuterRadiusMaxValue()
|
| GetOuterRadiusMinValue(...)
| GetOuterRadiusMinValue(self) -> float
| C++: virtual double GetOuterRadiusMinValue()
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetRadialResolution(...)
| GetRadialResolution(self) -> int
| C++: virtual int GetRadialResolution()
|
| GetRadialResolutionMaxValue(...)
| GetRadialResolutionMaxValue(self) -> int
| C++: virtual int GetRadialResolutionMaxValue()
|
| GetRadialResolutionMinValue(...)
| GetRadialResolutionMinValue(self) -> int
| C++: virtual int GetRadialResolutionMinValue()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkDiskSource
| C++: vtkDiskSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkDiskSource
| C++: static vtkDiskSource *SafeDownCast(vtkObjectBase *o)
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set the center of the disk. The default is (0, 0, 0).
|
| SetCircumferentialResolution(...)
| SetCircumferentialResolution(self, _arg:int) -> None
| C++: virtual void SetCircumferentialResolution(int _arg)
|
| Set the number of points in circumferential direction.
|
| SetInnerRadius(...)
| SetInnerRadius(self, _arg:float) -> None
| C++: virtual void SetInnerRadius(double _arg)
|
| Specify inner radius of hole in disk.
|
| SetNormal(...)
| SetNormal(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetNormal(double _arg1, double _arg2,
| double _arg3)
| SetNormal(self, _arg:(float, float, float)) -> None
| C++: virtual void SetNormal(const double _arg[3])
|
| Set/get plane normal. The default is (0, 0, 1).
|
| SetOuterRadius(...)
| SetOuterRadius(self, _arg:float) -> None
| C++: virtual void SetOuterRadius(double _arg)
|
| Specify outer radius of disk.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetRadialResolution(...)
| SetRadialResolution(self, _arg:int) -> None
| C++: virtual void SetRadialResolution(int _arg)
|
| Set the number of points in radius direction.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkDiskSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkDiskSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkDiskSource:
|
| __this__
| Pointer to the C++ object.
|
| circumferential_resolution
| read-write, calls GetCircumferentialResolution/SetCircumferentialResolution
|
| inner_radius
| read-write, calls GetInnerRadius/SetInnerRadius
|
| normal
| read-write, calls GetNormal/SetNormal
|
| outer_radius
| read-write, calls GetOuterRadius/SetOuterRadius
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| radial_resolution
| read-write, calls GetRadialResolution/SetRadialResolution
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkDiskSource:
|
| __vtkname__ = 'vtkDiskSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class LineSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkLineSource)
| LineSource(*args, **kwargs) -> '_T'
|
| Create a line.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| pointa : sequence[float], default: (-0.5, 0.0, 0.0)
| Location in ``[x, y, z]``.
|
| pointb : sequence[float], default: (0.5, 0.0, 0.0)
| Location in ``[x, y, z]``.
|
| resolution : int, default: 1
| Number of pieces to divide line into.
|
| Method resolution order:
| LineSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkLineSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'LineSource', pointa: 'VectorLike[float]' = (-0.5, 0.0, 0.0), pointb: 'VectorLike[float]' = (0.5, 0.0, 0.0), resolution: 'int' = 1) -> 'None'
| Initialize source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Line mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| pointa
| Location in ``[x, y, z]``.
|
| Returns
| -------
| sequence[float]
| Location in ``[x, y, z]``.
|
| pointb
| Location in ``[x, y, z]``.
|
| Returns
| -------
| sequence[float]
| Location in ``[x, y, z]``.
|
| resolution
| Number of pieces to divide line into.
|
| Returns
| -------
| int
| Number of pieces to divide line into.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfRefinementRatios(...)
| GetNumberOfRefinementRatios(self) -> int
| C++: int GetNumberOfRefinementRatios()
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetPoint1(...)
| GetPoint1(self) -> (float, float, float)
| C++: virtual double *GetPoint1()
|
| GetPoint2(...)
| GetPoint2(self) -> (float, float, float)
| C++: virtual double *GetPoint2()
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: virtual vtkPoints *GetPoints()
|
| GetRefinementRatio(...)
| GetRefinementRatio(self, index:int) -> float
| C++: double GetRefinementRatio(int index)
|
| GetResolution(...)
| GetResolution(self) -> int
| C++: virtual int GetResolution()
|
| GetResolutionMaxValue(...)
| GetResolutionMaxValue(self) -> int
| C++: virtual int GetResolutionMaxValue()
|
| GetResolutionMinValue(...)
| GetResolutionMinValue(self) -> int
| C++: virtual int GetResolutionMinValue()
|
| GetUseRegularRefinement(...)
| GetUseRegularRefinement(self) -> bool
| C++: virtual bool GetUseRegularRefinement()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkLineSource
| C++: vtkLineSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkLineSource
| C++: static vtkLineSource *SafeDownCast(vtkObjectBase *o)
|
| SetNumberOfRefinementRatios(...)
| SetNumberOfRefinementRatios(self, __a:int) -> None
| C++: void SetNumberOfRefinementRatios(int)
|
| API for setting/getting refinement ratios for points added to the
| line segment. The ratio is in the range `[0.0, 1.0]` where 0.0 is
| the start of the line segment and 1.0 is the end. When generating
| broken lines i.e. using `SetPoints`, this specifies refinement
| points for each of the individual line segment. Note that `0.0`
| and `1.0` must be explicitly included to generate a point and the
| start and/or end of the line segment. This is used only when
| `UseRegularRefinement` is false.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetPoint1(...)
| SetPoint1(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetPoint1(double _arg1, double _arg2,
| double _arg3)
| SetPoint1(self, _arg:(float, float, float)) -> None
| C++: virtual void SetPoint1(const double _arg[3])
|
| Set position of first end point.
|
| SetPoint2(...)
| SetPoint2(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetPoint2(double _arg1, double _arg2,
| double _arg3)
| SetPoint2(self, _arg:(float, float, float)) -> None
| C++: virtual void SetPoint2(const double _arg[3])
|
| Set position of other end point.
|
| SetPoints(...)
| SetPoints(self, __a:vtkPoints) -> None
| C++: virtual void SetPoints(vtkPoints *)
|
| Set/Get the list of points defining a broken line
|
| SetRefinementRatio(...)
| SetRefinementRatio(self, index:int, value:float) -> None
| C++: void SetRefinementRatio(int index, double value)
|
| SetResolution(...)
| SetResolution(self, _arg:int) -> None
| C++: virtual void SetResolution(int _arg)
|
| Divide line into Resolution number of pieces. This is used when
| `UseRegularRefinement` is true.
|
| SetUseRegularRefinement(...)
| SetUseRegularRefinement(self, _arg:bool) -> None
| C++: virtual void SetUseRegularRefinement(bool _arg)
|
| Set/Get how the line segment is to be refined. One can choose to
| add points at regular intervals per segment (defined using
| `Resolution`) or explicit locations (defined using
| `SetRefinementRatio`). Default is true i.e `Resolution` will be
| used to determine placement of points within each line segment.
|
| UseRegularRefinementOff(...)
| UseRegularRefinementOff(self) -> None
| C++: virtual void UseRegularRefinementOff()
|
| UseRegularRefinementOn(...)
| UseRegularRefinementOn(self) -> None
| C++: virtual void UseRegularRefinementOn()
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkLineSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| __this__
| Pointer to the C++ object.
|
| number_of_refinement_ratios
| read-write, calls GetNumberOfRefinementRatios/SetNumberOfRefinementRatios
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| point1
| read-write, calls GetPoint1/SetPoint1
|
| point2
| read-write, calls GetPoint2/SetPoint2
|
| points
| read-write, calls GetPoints/SetPoints
|
| use_regular_refinement
| read-write, calls GetUseRegularRefinement/SetUseRegularRefinement
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| __vtkname__ = 'vtkLineSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class MultipleLinesSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkLineSource)
| MultipleLinesSource(*args, **kwargs) -> '_T'
|
| Multiple lines source algorithm class.
|
| Parameters
| ----------
| points : array_like[float], default: [[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]]
| List of points defining a broken line.
|
| Method resolution order:
| MultipleLinesSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkLineSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'MultipleLinesSource', points: 'MatrixLike[float] | None' = None) -> 'None'
| Initialize the multiple lines source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Line mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| points
| Return the points defining a broken line.
|
| Returns
| -------
| np.ndarray
| Points defining a broken line.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfRefinementRatios(...)
| GetNumberOfRefinementRatios(self) -> int
| C++: int GetNumberOfRefinementRatios()
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetPoint1(...)
| GetPoint1(self) -> (float, float, float)
| C++: virtual double *GetPoint1()
|
| GetPoint2(...)
| GetPoint2(self) -> (float, float, float)
| C++: virtual double *GetPoint2()
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: virtual vtkPoints *GetPoints()
|
| GetRefinementRatio(...)
| GetRefinementRatio(self, index:int) -> float
| C++: double GetRefinementRatio(int index)
|
| GetResolution(...)
| GetResolution(self) -> int
| C++: virtual int GetResolution()
|
| GetResolutionMaxValue(...)
| GetResolutionMaxValue(self) -> int
| C++: virtual int GetResolutionMaxValue()
|
| GetResolutionMinValue(...)
| GetResolutionMinValue(self) -> int
| C++: virtual int GetResolutionMinValue()
|
| GetUseRegularRefinement(...)
| GetUseRegularRefinement(self) -> bool
| C++: virtual bool GetUseRegularRefinement()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkLineSource
| C++: vtkLineSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkLineSource
| C++: static vtkLineSource *SafeDownCast(vtkObjectBase *o)
|
| SetNumberOfRefinementRatios(...)
| SetNumberOfRefinementRatios(self, __a:int) -> None
| C++: void SetNumberOfRefinementRatios(int)
|
| API for setting/getting refinement ratios for points added to the
| line segment. The ratio is in the range `[0.0, 1.0]` where 0.0 is
| the start of the line segment and 1.0 is the end. When generating
| broken lines i.e. using `SetPoints`, this specifies refinement
| points for each of the individual line segment. Note that `0.0`
| and `1.0` must be explicitly included to generate a point and the
| start and/or end of the line segment. This is used only when
| `UseRegularRefinement` is false.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetPoint1(...)
| SetPoint1(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetPoint1(double _arg1, double _arg2,
| double _arg3)
| SetPoint1(self, _arg:(float, float, float)) -> None
| C++: virtual void SetPoint1(const double _arg[3])
|
| Set position of first end point.
|
| SetPoint2(...)
| SetPoint2(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetPoint2(double _arg1, double _arg2,
| double _arg3)
| SetPoint2(self, _arg:(float, float, float)) -> None
| C++: virtual void SetPoint2(const double _arg[3])
|
| Set position of other end point.
|
| SetPoints(...)
| SetPoints(self, __a:vtkPoints) -> None
| C++: virtual void SetPoints(vtkPoints *)
|
| Set/Get the list of points defining a broken line
|
| SetRefinementRatio(...)
| SetRefinementRatio(self, index:int, value:float) -> None
| C++: void SetRefinementRatio(int index, double value)
|
| SetResolution(...)
| SetResolution(self, _arg:int) -> None
| C++: virtual void SetResolution(int _arg)
|
| Divide line into Resolution number of pieces. This is used when
| `UseRegularRefinement` is true.
|
| SetUseRegularRefinement(...)
| SetUseRegularRefinement(self, _arg:bool) -> None
| C++: virtual void SetUseRegularRefinement(bool _arg)
|
| Set/Get how the line segment is to be refined. One can choose to
| add points at regular intervals per segment (defined using
| `Resolution`) or explicit locations (defined using
| `SetRefinementRatio`). Default is true i.e `Resolution` will be
| used to determine placement of points within each line segment.
|
| UseRegularRefinementOff(...)
| UseRegularRefinementOff(self) -> None
| C++: virtual void UseRegularRefinementOff()
|
| UseRegularRefinementOn(...)
| UseRegularRefinementOn(self) -> None
| C++: virtual void UseRegularRefinementOn()
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkLineSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| __this__
| Pointer to the C++ object.
|
| number_of_refinement_ratios
| read-write, calls GetNumberOfRefinementRatios/SetNumberOfRefinementRatios
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| point1
| read-write, calls GetPoint1/SetPoint1
|
| point2
| read-write, calls GetPoint2/SetPoint2
|
| resolution
| read-write, calls GetResolution/SetResolution
|
| use_regular_refinement
| read-write, calls GetUseRegularRefinement/SetUseRegularRefinement
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkLineSource:
|
| __vtkname__ = 'vtkLineSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class OrthogonalPlanesSource(pyvista.core.utilities.misc._NoNewAttrMixin)
| OrthogonalPlanesSource(*args, **kwargs) -> '_T'
|
| Orthogonal planes source.
|
| This source generates three orthogonal planes. The :attr:`output` is a
| :class:`~pyvista.MultiBlock` with named plane meshes ``'yz'``, ``'zx'``, ``'xy'``.
| The meshes are ordered such that the first, second, and third plane is perpendicular
| to the x, y, and z-axis, respectively.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| bounds : VectorLike[float], default: (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0)
| Specify the bounds of the planes in the form:
| ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| The generated planes are centered in these bounds.
|
| resolution : int | VectorLike[int], default: 2
| Number of points on the planes in the x-y-z directions. Use a single number
| for a uniform resolution, or three values to set independent resolutions.
|
| normal_sign : '+' | '-' | sequence['+' | '-'], default: '+'
| Sign of the plane's normal vectors. Use a single value to set all normals to
| the same sign, or three values to set them independently.
|
| names : sequence[str], default: ('xy','yz','zx')
| Name of each plane in the generated :class:`~pyvista.MultiBlock`.
|
| Examples
| --------
| Generate default orthogonal planes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> planes_source = pv.OrthogonalPlanesSource()
| >>> output = planes_source.output
| >>> output.plot()
|
| Modify the planes to fit a mesh's bounds.
|
| >>> human = examples.download_human()
| >>> planes_source.bounds = human.bounds
| >>> planes_source.update()
|
| Plot the mesh and the planes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(human, scalars='Color', rgb=True)
| >>> _ = pl.add_mesh(output, opacity=0.3, show_edges=True)
| >>> pl.show()
|
| The planes are centered geometrically, but the frontal plane is positioned a bit
| too far forward. Use :meth:`push` to move the frontal plane.
|
| >>> planes_source.push(0.0, -10.0, 0)
| >>> planes_source.update()
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(human, scalars='Color', rgb=True)
| >>> _ = pl.add_mesh(output, opacity=0.3, show_edges=True, line_width=10)
| >>> pl.view_yz()
| >>> pl.show()
|
| Method resolution order:
| OrthogonalPlanesSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'OrthogonalPlanesSource', bounds: 'VectorLike[float]' = (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0), *, resolution: 'int | VectorLike[int]' = 2, normal_sign: "Literal['+', '-'] | Sequence[str]" = '+', names: 'Sequence[str]' = ('yz', 'zx', 'xy')) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| push(self: 'OrthogonalPlanesSource', *distance: 'float | VectorLike[float]') -> 'None'
| Translate each plane by the specified distance along its normal.
|
| Internally, this method calls :meth:`pyvista.PlaneSource.push` on each
| plane source.
|
| Parameters
| ----------
| *distance : float | VectorLike[float], default: (0.0, 0.0, 0.0)
| Distance to move each plane.
|
| update(self: 'OrthogonalPlanesSource') -> 'None'
| Update the output of the source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output of the source.
|
| The output is a :class:`pyvista.MultiBlock` with three blocks: one for each
| plane. The blocks are named ``'yz'``, ``'zx'``, ``'xy'``, and are ordered such
| that the first, second, and third plane is perpendicular to the x, y, and
| z-axis, respectively.
|
| The source is automatically updated by :meth:`update` prior to returning
| the output.
|
| Returns
| -------
| pyvista.MultiBlock
| Composite mesh with three planes.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| bounds
| Return or set the bounds of the planes.
|
| names
| Return or set the names of the planes.
|
| normal_sign
| Return or set the sign of the plane's normal vectors.
|
| resolution
| Return or set the resolution of the planes.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class PlaneSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkPlaneSource)
| PlaneSource(*args, **kwargs) -> '_T'
|
| Create a plane source.
|
| The plane is defined by specifying an origin point, and then
| two other points that, together with the origin, define two
| axes for the plane (magnitude and direction). These axes do
| not have to be orthogonal - so you can create a parallelogram.
| The axes must not be parallel.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| i_resolution : int, default: 10
| Number of points on the plane in the i direction.
|
| j_resolution : int, default: 10
| Number of points on the plane in the j direction.
|
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Center in ``[x, y, z]``.
|
| origin : sequence[float], default: (-0.5, -0.5, 0.0)
| Origin in ``[x, y, z]``.
|
| point_a : sequence[float], default: (0.5, -0.5, 0.0)
| Location in ``[x, y, z]``.
|
| point_b : sequence[float], default: (-0.5, 0.5, 0.0)
| Location in ``[x, y, z]``.
|
| Method resolution order:
| PlaneSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkPlaneSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'PlaneSource', i_resolution: 'int' = 10, j_resolution: 'int' = 10, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), origin: 'VectorLike[float]' = (-0.5, -0.5, 0.0), point_a: 'VectorLike[float]' = (0.5, -0.5, 0.0), point_b: 'VectorLike[float]' = (-0.5, 0.5, 0.0)) -> 'None'
| Initialize source.
|
| flip_normal(self: 'PlaneSource') -> 'None'
| Flip the plane's normal.
|
| This method modifies the plane's :attr:`point_a` and :attr:`point_b` by
| swapping them.
|
| push(self: 'PlaneSource', distance: 'float') -> 'None'
| Translate the plane in the direction of the normal by the distance specified.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| normal
| Get the plane's normal vector.
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Plane mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Get the center in ``[x, y, z]``.
|
| The center of the plane is translated to the specified point.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``.
|
| i_resolution
| Number of points on the plane in the i direction.
|
| Returns
| -------
| int
| Number of points on the plane in the i direction.
|
| j_resolution
| Number of points on the plane in the j direction.
|
| Returns
| -------
| int
| Number of points on the plane in the j direction.
|
| origin
| Get the origin in ``[x, y, z]``.
|
| Returns
| -------
| sequence[float]
| Origin in ``[x, y, z]``.
|
| point_a
| Get the Location in ``[x, y, z]``.
|
| Returns
| -------
| sequence[float]
| Location in ``[x, y, z]``.
|
| point_b
| Get the Location in ``[x, y, z]``.
|
| Returns
| -------
| sequence[float]
| Location in ``[x, y, z]``.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkPlaneSource:
|
| GetAxis1(...)
| GetAxis1(self, a1:[float, float, float]) -> None
| C++: void GetAxis1(double a1[3])
|
| Convenience methods to retrieve the axes of the plane; that is
| axis a1 is the vector (Point1-Origin), and axis a2 is the vector
| (Point2-Origin).
|
| GetAxis2(...)
| GetAxis2(self, a2:[float, float, float]) -> None
| C++: void GetAxis2(double a2[3])
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetNormal(...)
| GetNormal(self) -> (float, float, float)
| C++: virtual double *GetNormal()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOrigin(...)
| GetOrigin(self) -> (float, float, float)
| C++: virtual double *GetOrigin()
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetPoint1(...)
| GetPoint1(self) -> (float, float, float)
| C++: virtual double *GetPoint1()
|
| GetPoint2(...)
| GetPoint2(self) -> (float, float, float)
| C++: virtual double *GetPoint2()
|
| GetResolution(...)
| GetResolution(self, xR:int, yR:int) -> None
| C++: void GetResolution(int &xR, int &yR)
|
| GetXResolution(...)
| GetXResolution(self) -> int
| C++: virtual int GetXResolution()
|
| GetYResolution(...)
| GetYResolution(self) -> int
| C++: virtual int GetYResolution()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkPlaneSource
| C++: vtkPlaneSource *NewInstance()
|
| Push(...)
| Push(self, distance:float) -> None
| C++: void Push(double distance)
|
| Translate the plane in the direction of the normal by the
| distance specified. Negative values move the plane in the
| opposite direction.
|
| Rotate(...)
| Rotate(self, angle:float, rotationAxis:[float, float, float])
| -> None
| C++: void Rotate(double angle, double rotationAxis[3])
|
| Rotate plane at center around a given axis If the absolute value
| of the angle is inferior to the defined EPSILON, then don't
| rotate
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkPlaneSource
| C++: static vtkPlaneSource *SafeDownCast(vtkObjectBase *o)
|
| SetCenter(...)
| SetCenter(self, x:float, y:float, z:float) -> None
| C++: void SetCenter(double x, double y, double z)
| SetCenter(self, center:[float, float, float]) -> None
| C++: void SetCenter(double center[3])
|
| Set/Get the center of the plane. Works in conjunction with the
| plane normal to position the plane. Don't use this method to
| define the plane. Instead, use it to move the plane to a new
| center point.
|
| SetNormal(...)
| SetNormal(self, nx:float, ny:float, nz:float) -> None
| C++: void SetNormal(double nx, double ny, double nz)
| SetNormal(self, n:[float, float, float]) -> None
| C++: void SetNormal(double n[3])
|
| Set/Get the plane normal. Works in conjunction with the plane
| center to orient the plane. Don't use this method to define the
| plane. Instead, use it to rotate the plane around the current
| center point.
|
| SetOrigin(...)
| SetOrigin(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetOrigin(double _arg1, double _arg2,
| double _arg3)
| SetOrigin(self, _arg:(float, float, float)) -> None
| C++: virtual void SetOrigin(const double _arg[3])
|
| Specify a point defining the origin of the plane.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetPoint1(...)
| SetPoint1(self, x:float, y:float, z:float) -> None
| C++: void SetPoint1(double x, double y, double z)
| SetPoint1(self, pnt:[float, float, float]) -> None
| C++: void SetPoint1(double pnt[3])
|
| Specify a point defining the first axis of the plane.
|
| SetPoint2(...)
| SetPoint2(self, x:float, y:float, z:float) -> None
| C++: void SetPoint2(double x, double y, double z)
| SetPoint2(self, pnt:[float, float, float]) -> None
| C++: void SetPoint2(double pnt[3])
|
| Specify a point defining the second axis of the plane.
|
| SetResolution(...)
| SetResolution(self, xR:int, yR:int) -> None
| C++: void SetResolution(int xR, int yR)
|
| Set the number of x-y subdivisions in the plane.
|
| SetXResolution(...)
| SetXResolution(self, _arg:int) -> None
| C++: virtual void SetXResolution(int _arg)
|
| Specify the resolution of the plane along the first axes.
|
| SetYResolution(...)
| SetYResolution(self, _arg:int) -> None
| C++: virtual void SetYResolution(int _arg)
|
| Specify the resolution of the plane along the second axes.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkPlaneSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkPlaneSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkPlaneSource:
|
| __this__
| Pointer to the C++ object.
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| point1
| read-write, calls GetPoint1/SetPoint1
|
| point2
| read-write, calls GetPoint2/SetPoint2
|
| resolution
| write-only, calls SetResolution
|
| x_resolution
| read-write, calls GetXResolution/SetXResolution
|
| y_resolution
| read-write, calls GetYResolution/SetYResolution
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkPlaneSource:
|
| __vtkname__ = 'vtkPlaneSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class PlatonicSolidSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource)
| PlatonicSolidSource(*args, **kwargs) -> '_T'
|
| Platonic solid source algorithm class.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| kind : str | int, default: 'tetrahedron'
| The kind of Platonic solid to create. Either the name of the
| polyhedron or an integer index:
|
| * ``'tetrahedron'`` or ``0``
| * ``'cube'`` or ``1``
| * ``'octahedron'`` or ``2``
| * ``'icosahedron'`` or ``3``
| * ``'dodecahedron'`` or ``4``
|
| Examples
| --------
| Create and plot a dodecahedron.
|
| >>> import pyvista as pv
| >>> dodeca = pv.PlatonicSolidSource('dodecahedron')
| >>> dodeca.output.plot(categories=True)
|
| See :ref:`create_platonic_solids_example` for more examples using this filter.
|
| Method resolution order:
| PlatonicSolidSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'PlatonicSolidSource', kind: 'str' = 'tetrahedron') -> 'None'
| Initialize the platonic solid source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| PlatonicSolid surface.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| kind
| Get the kind of Platonic solid to create.
|
| Returns
| -------
| str
| The kind of Platonic solid to create.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource:
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetSolidType(...)
| GetSolidType(self) -> int
| C++: virtual int GetSolidType()
|
| GetSolidTypeMaxValue(...)
| GetSolidTypeMaxValue(self) -> int
| C++: virtual int GetSolidTypeMaxValue()
|
| GetSolidTypeMinValue(...)
| GetSolidTypeMinValue(self) -> int
| C++: virtual int GetSolidTypeMinValue()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkPlatonicSolidSource
| C++: vtkPlatonicSolidSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkPlatonicSolidSource
| C++: static vtkPlatonicSolidSource *SafeDownCast(vtkObjectBase *o)
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetSolidType(...)
| SetSolidType(self, _arg:int) -> None
| C++: virtual void SetSolidType(int _arg)
|
| Specify the type of PlatonicSolid solid to create.
|
| SetSolidTypeToCube(...)
| SetSolidTypeToCube(self) -> None
| C++: void SetSolidTypeToCube()
|
| SetSolidTypeToDodecahedron(...)
| SetSolidTypeToDodecahedron(self) -> None
| C++: void SetSolidTypeToDodecahedron()
|
| SetSolidTypeToIcosahedron(...)
| SetSolidTypeToIcosahedron(self) -> None
| C++: void SetSolidTypeToIcosahedron()
|
| SetSolidTypeToOctahedron(...)
| SetSolidTypeToOctahedron(self) -> None
| C++: void SetSolidTypeToOctahedron()
|
| SetSolidTypeToTetrahedron(...)
| SetSolidTypeToTetrahedron(self) -> None
| C++: void SetSolidTypeToTetrahedron()
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource:
|
| __this__
| Pointer to the C++ object.
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| solid_type
| read-write, calls GetSolidType/SetSolidType
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkPlatonicSolidSource:
|
| __vtkname__ = 'vtkPlatonicSolidSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class PolygonSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkRegularPolygonSource)
| PolygonSource(*args, **kwargs) -> '_T'
|
| Polygon source algorithm class.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Center in ``[x, y, z]``. Central axis of the polygon passes
| through this point.
|
| radius : float, default: 1.0
| The radius of the polygon.
|
| normal : sequence[float], default: (0.0, 0.0, 1.0)
| Direction vector in ``[x, y, z]``. Orientation vector of the polygon.
|
| n_sides : int, default: 6
| Number of sides of the polygon.
|
| fill : bool, default: True
| Enable or disable producing filled polygons.
|
| Examples
| --------
| Create an 8 sided polygon.
|
| >>> import pyvista as pv
| >>> source = pv.PolygonSource(n_sides=8)
| >>> source.output.plot(show_edges=True, line_width=5)
|
| Method resolution order:
| PolygonSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkRegularPolygonSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'PolygonSource', center: 'VectorLike[float]' = (0.0, 0.0, 0.0), radius: 'float' = 1.0, normal: 'VectorLike[float]' = (0.0, 0.0, 1.0), n_sides: 'int' = 6, fill: 'bool' = True) -> 'None'
| Initialize the polygon source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Polygon surface.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Get the center in ``[x, y, z]``.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``.
|
| fill
| Get enable or disable producing filled polygons.
|
| Returns
| -------
| bool
| Enable or disable producing filled polygons.
|
| n_sides
| Get number of sides of the polygon.
|
| Returns
| -------
| int
| Number of sides of the polygon.
|
| normal
| Get the normal in ``[x, y, z]``.
|
| Returns
| -------
| sequence[float]
| Normal in ``[x, y, z]``.
|
| radius
| Get the radius of the polygon.
|
| Returns
| -------
| float
| The radius of the polygon.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkRegularPolygonSource:
|
| GeneratePolygonOff(...)
| GeneratePolygonOff(self) -> None
| C++: virtual void GeneratePolygonOff()
|
| GeneratePolygonOn(...)
| GeneratePolygonOn(self) -> None
| C++: virtual void GeneratePolygonOn()
|
| GeneratePolylineOff(...)
| GeneratePolylineOff(self) -> None
| C++: virtual void GeneratePolylineOff()
|
| GeneratePolylineOn(...)
| GeneratePolylineOn(self) -> None
| C++: virtual void GeneratePolylineOn()
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetGeneratePolygon(...)
| GetGeneratePolygon(self) -> int
| C++: virtual vtkTypeBool GetGeneratePolygon()
|
| GetGeneratePolyline(...)
| GetGeneratePolyline(self) -> int
| C++: virtual vtkTypeBool GetGeneratePolyline()
|
| GetNormal(...)
| GetNormal(self) -> (float, float, float)
| C++: virtual double *GetNormal()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfSides(...)
| GetNumberOfSides(self) -> int
| C++: virtual int GetNumberOfSides()
|
| GetNumberOfSidesMaxValue(...)
| GetNumberOfSidesMaxValue(self) -> int
| C++: virtual int GetNumberOfSidesMaxValue()
|
| GetNumberOfSidesMinValue(...)
| GetNumberOfSidesMinValue(self) -> int
| C++: virtual int GetNumberOfSidesMinValue()
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetRadius(...)
| GetRadius(self) -> float
| C++: virtual double GetRadius()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkRegularPolygonSource
| C++: vtkRegularPolygonSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkRegularPolygonSource
| C++: static vtkRegularPolygonSource *SafeDownCast(
| vtkObjectBase *o)
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set/Get the center of the polygon. By default, the center is set
| at the origin (0,0,0).
|
| SetGeneratePolygon(...)
| SetGeneratePolygon(self, _arg:int) -> None
| C++: virtual void SetGeneratePolygon(vtkTypeBool _arg)
|
| Control whether a polygon is produced. By default,
| GeneratePolygon is enabled.
|
| SetGeneratePolyline(...)
| SetGeneratePolyline(self, _arg:int) -> None
| C++: virtual void SetGeneratePolyline(vtkTypeBool _arg)
|
| Control whether a polyline is produced. By default,
| GeneratePolyline is enabled.
|
| SetNormal(...)
| SetNormal(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetNormal(double _arg1, double _arg2,
| double _arg3)
| SetNormal(self, _arg:(float, float, float)) -> None
| C++: virtual void SetNormal(const double _arg[3])
|
| Set/Get the normal to the polygon. The ordering of the polygon
| will be counter-clockwise around the normal (i.e., using the
| right-hand rule). By default, the normal is set to (0,0,1).
|
| SetNumberOfSides(...)
| SetNumberOfSides(self, _arg:int) -> None
| C++: virtual void SetNumberOfSides(int _arg)
|
| Set/Get the number of sides of the polygon. By default, the
| number of sides is set to six.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetRadius(...)
| SetRadius(self, _arg:float) -> None
| C++: virtual void SetRadius(double _arg)
|
| Set/Get the radius of the polygon. By default, the radius is set
| to 0.5.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkRegularPolygonSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkRegularPolygonSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkRegularPolygonSource:
|
| __this__
| Pointer to the C++ object.
|
| generate_polygon
| read-write, calls GetGeneratePolygon/SetGeneratePolygon
|
| generate_polyline
| read-write, calls GetGeneratePolyline/SetGeneratePolyline
|
| number_of_sides
| read-write, calls GetNumberOfSides/SetNumberOfSides
|
| number_of_sides_max_value
| read-only, calls GetNumberOfSidesMaxValue
|
| number_of_sides_min_value
| read-only, calls GetNumberOfSidesMinValue
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkRegularPolygonSource:
|
| __vtkname__ = 'vtkRegularPolygonSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class SphereSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkSphereSource)
| SphereSource(*args, **kwargs) -> '_T'
|
| Sphere source algorithm class.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| radius : float, default: 0.5
| Sphere radius.
|
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Center coordinate vector in ``[x, y, z]``.
|
| theta_resolution : int, default: 30
| Set the number of points in the azimuthal direction (ranging
| from ``start_theta`` to ``end_theta``).
|
| phi_resolution : int, default: 30
| Set the number of points in the polar direction (ranging from
| ``start_phi`` to ``end_phi``).
|
| start_theta : float, default: 0.0
| Starting azimuthal angle in degrees ``[0, 360]``.
|
| end_theta : float, default: 360.0
| Ending azimuthal angle in degrees ``[0, 360]``.
|
| start_phi : float, default: 0.0
| Starting polar angle in degrees ``[0, 180]``.
|
| end_phi : float, default: 180.0
| Ending polar angle in degrees ``[0, 180]``.
|
| See Also
| --------
| pyvista.Icosphere : Sphere created from projection of icosahedron.
| pyvista.SolidSphere : Sphere that fills 3D space.
|
| Examples
| --------
| Create a sphere using default parameters.
|
| >>> import pyvista as pv
| >>> sphere = pv.SphereSource()
| >>> sphere.output.plot(show_edges=True)
|
| Create a quarter sphere by setting ``end_theta``.
|
| >>> sphere = pv.SphereSource(end_theta=90)
| >>> out = sphere.output.plot(show_edges=True)
|
| Create a hemisphere by setting ``end_phi``.
|
| >>> sphere = pv.SphereSource(end_phi=90)
| >>> out = sphere.output.plot(show_edges=True)
|
| Method resolution order:
| SphereSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkSphereSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'SphereSource', radius: 'float' = 0.5, center: 'VectorLike[float] | None' = None, theta_resolution: 'int' = 30, phi_resolution: 'int' = 30, start_theta: 'float' = 0.0, end_theta: 'float' = 360.0, start_phi: 'float' = 0.0, end_phi: 'float' = 180.0) -> 'None'
| Initialize the sphere source class.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Sphere surface.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Get the center in ``[x, y, z]``.
|
| Returns
| -------
| tuple[float, float, float]
| Center in ``[x, y, z]``.
|
| end_phi
| Get ending polar angle in degrees ``[0, 360]``.
|
| Returns
| -------
| float
| The number of points in the polar direction.
|
| end_theta
| Get ending azimuthal angle in degrees ``[0, 360]``.
|
| Returns
| -------
| float
| The number of points in the azimuthal direction.
|
| phi_resolution
| Get the number of points in the polar direction.
|
| Returns
| -------
| int
| The number of points in the polar direction.
|
| radius
| Get sphere radius.
|
| Returns
| -------
| float
| Sphere radius.
|
| start_phi
| Get starting polar angle in degrees ``[0, 360]``.
|
| Returns
| -------
| float
| The number of points in the polar direction.
|
| start_theta
| Get starting azimuthal angle in degrees ``[0, 360]``.
|
| Returns
| -------
| float
| The number of points in the azimuthal direction.
|
| theta_resolution
| Get the number of points in the azimuthal direction.
|
| Returns
| -------
| int
| The number of points in the azimuthal direction.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkSphereSource:
|
| GenerateNormalsOff(...)
| GenerateNormalsOff(self) -> None
| C++: virtual void GenerateNormalsOff()
|
| GenerateNormalsOn(...)
| GenerateNormalsOn(self) -> None
| C++: virtual void GenerateNormalsOn()
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetEndPhi(...)
| GetEndPhi(self) -> float
| C++: virtual double GetEndPhi()
|
| GetEndPhiMaxValue(...)
| GetEndPhiMaxValue(self) -> float
| C++: virtual double GetEndPhiMaxValue()
|
| GetEndPhiMinValue(...)
| GetEndPhiMinValue(self) -> float
| C++: virtual double GetEndPhiMinValue()
|
| GetEndTheta(...)
| GetEndTheta(self) -> float
| C++: virtual double GetEndTheta()
|
| GetEndThetaMaxValue(...)
| GetEndThetaMaxValue(self) -> float
| C++: virtual double GetEndThetaMaxValue()
|
| GetEndThetaMinValue(...)
| GetEndThetaMinValue(self) -> float
| C++: virtual double GetEndThetaMinValue()
|
| GetGenerateNormals(...)
| GetGenerateNormals(self) -> int
| C++: virtual vtkTypeBool GetGenerateNormals()
|
| GetLatLongTessellation(...)
| GetLatLongTessellation(self) -> int
| C++: virtual vtkTypeBool GetLatLongTessellation()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetPhiResolution(...)
| GetPhiResolution(self) -> int
| C++: virtual int GetPhiResolution()
|
| GetPhiResolutionMaxValue(...)
| GetPhiResolutionMaxValue(self) -> int
| C++: virtual int GetPhiResolutionMaxValue()
|
| GetPhiResolutionMinValue(...)
| GetPhiResolutionMinValue(self) -> int
| C++: virtual int GetPhiResolutionMinValue()
|
| GetRadius(...)
| GetRadius(self) -> float
| C++: virtual double GetRadius()
|
| GetRadiusMaxValue(...)
| GetRadiusMaxValue(self) -> float
| C++: virtual double GetRadiusMaxValue()
|
| GetRadiusMinValue(...)
| GetRadiusMinValue(self) -> float
| C++: virtual double GetRadiusMinValue()
|
| GetStartPhi(...)
| GetStartPhi(self) -> float
| C++: virtual double GetStartPhi()
|
| GetStartPhiMaxValue(...)
| GetStartPhiMaxValue(self) -> float
| C++: virtual double GetStartPhiMaxValue()
|
| GetStartPhiMinValue(...)
| GetStartPhiMinValue(self) -> float
| C++: virtual double GetStartPhiMinValue()
|
| GetStartTheta(...)
| GetStartTheta(self) -> float
| C++: virtual double GetStartTheta()
|
| GetStartThetaMaxValue(...)
| GetStartThetaMaxValue(self) -> float
| C++: virtual double GetStartThetaMaxValue()
|
| GetStartThetaMinValue(...)
| GetStartThetaMinValue(self) -> float
| C++: virtual double GetStartThetaMinValue()
|
| GetThetaResolution(...)
| GetThetaResolution(self) -> int
| C++: virtual int GetThetaResolution()
|
| GetThetaResolutionMaxValue(...)
| GetThetaResolutionMaxValue(self) -> int
| C++: virtual int GetThetaResolutionMaxValue()
|
| GetThetaResolutionMinValue(...)
| GetThetaResolutionMinValue(self) -> int
| C++: virtual int GetThetaResolutionMinValue()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| LatLongTessellationOff(...)
| LatLongTessellationOff(self) -> None
| C++: virtual void LatLongTessellationOff()
|
| LatLongTessellationOn(...)
| LatLongTessellationOn(self) -> None
| C++: virtual void LatLongTessellationOn()
|
| NewInstance(...)
| NewInstance(self) -> vtkSphereSource
| C++: vtkSphereSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkSphereSource
| C++: static vtkSphereSource *SafeDownCast(vtkObjectBase *o)
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set the center of the sphere. Default is (0,0,0).
|
| SetEndPhi(...)
| SetEndPhi(self, _arg:float) -> None
| C++: virtual void SetEndPhi(double _arg)
|
| Set the ending latitude angle. By default EndPhi=180 degrees.
|
| SetEndTheta(...)
| SetEndTheta(self, _arg:float) -> None
| C++: virtual void SetEndTheta(double _arg)
|
| Set the ending longitude angle. By default EndTheta=360 degrees.
|
| SetGenerateNormals(...)
| SetGenerateNormals(self, _arg:int) -> None
| C++: virtual void SetGenerateNormals(vtkTypeBool _arg)
|
| Specify whether to generate output point normals. By default this
| is enabled.
|
| SetLatLongTessellation(...)
| SetLatLongTessellation(self, _arg:int) -> None
| C++: virtual void SetLatLongTessellation(vtkTypeBool _arg)
|
| Cause the sphere to be tessellated with edges along the latitude
| and longitude lines. If off, triangles are generated at non-polar
| regions, which results in edges that are not parallel to latitude
| and longitude lines. If on, quadrilaterals are generated
| everywhere except at the poles. This can be useful for generating
| a wireframe sphere with natural latitude and longitude lines.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetPhiResolution(...)
| SetPhiResolution(self, _arg:int) -> None
| C++: virtual void SetPhiResolution(int _arg)
|
| Set the number of points in the latitude direction (ranging from
| StartPhi to EndPhi).
|
| SetRadius(...)
| SetRadius(self, _arg:float) -> None
| C++: virtual void SetRadius(double _arg)
|
| Set the radius of sphere. Default is 0.5.
|
| SetStartPhi(...)
| SetStartPhi(self, _arg:float) -> None
| C++: virtual void SetStartPhi(double _arg)
|
| Set the starting latitude angle (0 is at north pole). By default
| StartPhi=0 degrees.
|
| SetStartTheta(...)
| SetStartTheta(self, _arg:float) -> None
| C++: virtual void SetStartTheta(double _arg)
|
| Set the starting longitude angle. By default StartTheta=0
| degrees.
|
| SetThetaResolution(...)
| SetThetaResolution(self, _arg:int) -> None
| C++: virtual void SetThetaResolution(int _arg)
|
| Set the number of points in the longitude direction (ranging from
| StartTheta to EndTheta).
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkSphereSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkSphereSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkSphereSource:
|
| __this__
| Pointer to the C++ object.
|
| generate_normals
| read-write, calls GetGenerateNormals/SetGenerateNormals
|
| lat_long_tessellation
| read-write, calls GetLatLongTessellation/SetLatLongTessellation
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkSphereSource:
|
| __vtkname__ = 'vtkSphereSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class SuperquadricSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkFiltersSources.vtkSuperquadricSource)
| SuperquadricSource(*args, **kwargs) -> '_T'
|
| Create superquadric source.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| center : sequence[float], default: (0.0, 0.0, 0.0)
| Center of the superquadric in ``[x, y, z]``.
|
| scale : sequence[float], default: (1.0, 1.0, 1.0)
| Scale factors of the superquadric in ``[x, y, z]``.
|
| size : float, default: 0.5
| Superquadric isotropic size.
|
| theta_roundness : float, default: 1.0
| Superquadric east/west roundness.
| Values range from 0 (rectangular) to 1 (circular) to higher orders.
|
| phi_roundness : float, default: 1.0
| Superquadric north/south roundness.
| Values range from 0 (rectangular) to 1 (circular) to higher orders.
|
| theta_resolution : int, default: 16
| Number of points in the longitude direction.
| Values are rounded to nearest multiple of 4.
|
| phi_resolution : int, default: 16
| Number of points in the latitude direction.
| Values are rounded to nearest multiple of 8.
|
| toroidal : bool, default: False
| Whether or not the superquadric is toroidal (``True``)
| or ellipsoidal (``False``).
|
| thickness : float, default: 0.3333333333
| Superquadric ring thickness.
| Only applies if toroidal is set to ``True``.
|
| Method resolution order:
| SuperquadricSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkFiltersSources.vtkSuperquadricSource
| vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'SuperquadricSource', center: 'VectorLike[float]' = (0.0, 0.0, 0.0), scale: 'VectorLike[float]' = (1.0, 1.0, 1.0), size: 'float' = 0.5, theta_roundness: 'float' = 1.0, phi_roundness: 'float' = 1.0, theta_resolution: 'int' = 16, phi_resolution: 'int' = 16, toroidal: 'bool' = False, thickness: 'float' = 0.3333333333333333) -> 'None'
| Initialize source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output data object for a port on this algorithm.
|
| Returns
| -------
| pyvista.PolyData
| Plane mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Center of the superquadric in ``[x, y, z]``.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the superquadric in ``[x, y, z]``.
|
| phi_resolution
| Number of points in the latitude direction.
|
| Returns
| -------
| float
| Number of points in the latitude direction.
|
| phi_roundness
| Superquadric north/south roundness.
|
| Returns
| -------
| float
| Superquadric north/south roundness.
|
| scale
| Scale factors of the superquadric in ``[x, y, z]``.
|
| Returns
| -------
| sequence[float]
| Scale factors of the superquadric in ``[x, y, z]``.
|
| size
| Superquadric isotropic size.
|
| Returns
| -------
| float
| Superquadric isotropic size.
|
| theta_resolution
| Number of points in the longitude direction.
|
| Returns
| -------
| float
| Number of points in the longitude direction.
|
| theta_roundness
| Superquadric east/west roundness.
|
| Returns
| -------
| float
| Superquadric east/west roundness.
|
| thickness
| Superquadric ring thickness.
|
| Returns
| -------
| float
| Superquadric ring thickness.
|
| toroidal
| Whether or not the superquadric is toroidal (``True``) or ellipsoidal (``False``).
|
| Returns
| -------
| bool
| Whether or not the superquadric is toroidal (``True``)
| or ellipsoidal (``False``).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkFiltersSources.vtkSuperquadricSource:
|
| GetAxisOfSymmetry(...)
| GetAxisOfSymmetry(self) -> int
| C++: virtual int GetAxisOfSymmetry()
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutputPointsPrecision(...)
| GetOutputPointsPrecision(self) -> int
| C++: virtual int GetOutputPointsPrecision()
|
| GetPhiResolution(...)
| GetPhiResolution(self) -> int
| C++: virtual int GetPhiResolution()
|
| Set the number of points in the latitude direction. Initial value
| is 16.
|
| GetPhiRoundness(...)
| GetPhiRoundness(self) -> float
| C++: virtual double GetPhiRoundness()
|
| Set/Get Superquadric north/south roundness. Values range from 0
| (rectangular) to 1 (circular) to higher orders. Initial value is
| 1.0.
|
| GetScale(...)
| GetScale(self) -> (float, float, float)
| C++: virtual double *GetScale()
|
| GetSize(...)
| GetSize(self) -> float
| C++: virtual double GetSize()
|
| GetThetaResolution(...)
| GetThetaResolution(self) -> int
| C++: virtual int GetThetaResolution()
|
| Set the number of points in the longitude direction. Initial
| value is 16.
|
| GetThetaRoundness(...)
| GetThetaRoundness(self) -> float
| C++: virtual double GetThetaRoundness()
|
| Set/Get Superquadric east/west roundness. Values range from 0
| (rectangular) to 1 (circular) to higher orders. Initial value is
| 1.0.
|
| GetThickness(...)
| GetThickness(self) -> float
| C++: virtual double GetThickness()
|
| Set/Get Superquadric ring thickness (toroids only). Changing
| thickness maintains the outside diameter of the toroid. Initial
| value is 0.3333.
|
| GetThicknessMaxValue(...)
| GetThicknessMaxValue(self) -> float
| C++: virtual double GetThicknessMaxValue()
|
| GetThicknessMinValue(...)
| GetThicknessMinValue(self) -> float
| C++: virtual double GetThicknessMinValue()
|
| GetToroidal(...)
| GetToroidal(self) -> int
| C++: virtual vtkTypeBool GetToroidal()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkSuperquadricSource
| C++: vtkSuperquadricSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkSuperquadricSource
| C++: static vtkSuperquadricSource *SafeDownCast(vtkObjectBase *o)
|
| SetAxisOfSymmetry(...)
| SetAxisOfSymmetry(self, _arg:int) -> None
| C++: virtual void SetAxisOfSymmetry(int _arg)
|
| Set/Get axis of symmetry for superquadric (x axis: 0, y axis: 1,
| z axis: 2). Initial value is 1.
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set the center of the superquadric. Default is 0,0,0.
|
| SetOutputPointsPrecision(...)
| SetOutputPointsPrecision(self, _arg:int) -> None
| C++: virtual void SetOutputPointsPrecision(int _arg)
|
| Set/get the desired precision for the output points.
| vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating
| point. vtkAlgorithm::DOUBLE_PRECISION - Output double-precision
| floating point.
|
| SetPhiResolution(...)
| SetPhiResolution(self, i:int) -> None
| C++: void SetPhiResolution(int i)
|
| SetPhiRoundness(...)
| SetPhiRoundness(self, e:float) -> None
| C++: void SetPhiRoundness(double e)
|
| SetScale(...)
| SetScale(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetScale(double _arg1, double _arg2,
| double _arg3)
| SetScale(self, _arg:(float, float, float)) -> None
| C++: virtual void SetScale(const double _arg[3])
|
| Set the scale factors of the superquadric. Default is 1,1,1.
|
| SetSize(...)
| SetSize(self, _arg:float) -> None
| C++: virtual void SetSize(double _arg)
|
| Set/Get Superquadric isotropic size. Initial value is 0.5;
|
| SetThetaResolution(...)
| SetThetaResolution(self, i:int) -> None
| C++: void SetThetaResolution(int i)
|
| SetThetaRoundness(...)
| SetThetaRoundness(self, e:float) -> None
| C++: void SetThetaRoundness(double e)
|
| SetThickness(...)
| SetThickness(self, _arg:float) -> None
| C++: virtual void SetThickness(double _arg)
|
| SetToroidal(...)
| SetToroidal(self, _arg:int) -> None
| C++: virtual void SetToroidal(vtkTypeBool _arg)
|
| SetXAxisOfSymmetry(...)
| SetXAxisOfSymmetry(self) -> None
| C++: void SetXAxisOfSymmetry()
|
| SetYAxisOfSymmetry(...)
| SetYAxisOfSymmetry(self) -> None
| C++: void SetYAxisOfSymmetry()
|
| SetZAxisOfSymmetry(...)
| SetZAxisOfSymmetry(self) -> None
| C++: void SetZAxisOfSymmetry()
|
| ToroidalOff(...)
| ToroidalOff(self) -> None
| C++: virtual void ToroidalOff()
|
| ToroidalOn(...)
| ToroidalOn(self) -> None
| C++: virtual void ToroidalOn()
|
| Set/Get whether or not the superquadric is toroidal (1) or
| ellipsoidal (0). Initial value is 0.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkFiltersSources.vtkSuperquadricSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkFiltersSources.vtkSuperquadricSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkFiltersSources.vtkSuperquadricSource:
|
| __this__
| Pointer to the C++ object.
|
| axis_of_symmetry
| read-write, calls GetAxisOfSymmetry/SetAxisOfSymmetry
|
| output_points_precision
| read-write, calls GetOutputPointsPrecision/SetOutputPointsPrecision
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkFiltersSources.vtkSuperquadricSource:
|
| __vtkname__ = 'vtkSuperquadricSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use AddInputConnection() to
| setup a pipeline connection.
|
| GetInput(...)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
|
| GetOutput(...)
| GetOutput(self) -> vtkPolyData
| C++: vtkPolyData *GetOutput()
| GetOutput(self, __a:int) -> vtkPolyData
| C++: vtkPolyData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| GetPolyDataInput(...)
| GetPolyDataInput(self, port:int) -> vtkPolyData
| C++: vtkPolyData *GetPolyDataInput(int port)
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection() to
| setup a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkPolyDataAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class Text3DSource(pyvista.core.utilities.misc._NoNewAttrMixin)
| Text3DSource(*args, **kwargs) -> '_T'
|
| 3D text from a string.
|
| Generate 3D text from a string with a specified width, height or depth.
|
| .. versionadded:: 0.43
|
| .. versionchanged:: 0.48
|
| This class no longer inherits from :vtk:`vtkVectorText`, and uses composition instead.
|
| Parameters
| ----------
| string : str, default: ""
| Text string of the source.
|
| depth : float, optional
| Depth of the text. If ``None``, the depth is set to half
| the :attr:`height` by default. Set to ``0.0`` for planar
| text.
|
| width : float, optional
| Width of the text. If ``None``, the width is scaled
| proportional to :attr:`height`.
|
| height : float, optional
| Height of the text. If ``None``, the height is scaled
| proportional to :attr:`width`.
|
| center : Sequence[float], default: (0.0, 0.0, 0.0)
| Center of the text, defined as the middle of the axis-aligned
| bounding box of the text.
|
| normal : Sequence[float], default: (0.0, 0.0, 1.0)
| Normal direction of the text. The direction is parallel to the
| :attr:`depth` of the text and points away from the front surface
| of the text.
|
| process_empty_string : bool, default: True
| If ``True``, when :attr:`string` is empty the :attr:`output` is a
| single point located at :attr:`center` instead of an empty mesh.
| See :attr:`process_empty_string` for details.
|
| Method resolution order:
| Text3DSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'Text3DSource', string: 'str | None' = None, depth: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, center: 'VectorLike[float]' = (0.0, 0.0, 0.0), normal: 'VectorLike[float]' = (0.0, 0.0, 1.0), process_empty_string: 'bool' = True) -> 'None'
| Initialize source.
|
| __setattr__(self: 'Text3DSource', name: 'str', value: 'Any') -> 'None'
| Override to set modified flag and disable setting new attributes.
|
| update(self: 'Text3DSource') -> 'None'
| Update the output of the source.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output of the source.
|
| The source is automatically updated by :meth:`update` prior
| to returning the output.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Return or set the center of the text.
|
| The center is defined as the middle of the axis-aligned bounding box
| of the text.
|
| depth
| Return or set the depth of the text.
|
| height
| Return or set the height of the text.
|
| normal
| Return or set the normal direction of the text.
|
| The normal direction is parallel to the :attr:`depth` of the text, and
| points away from the front surface of the text.
|
| process_empty_string
| Return or set flag to control behavior when empty strings are set.
|
| When :attr:`string` is empty or only contains whitespace, the :attr:`output`
| mesh will be empty. This can cause the bounds of the output to be undefined.
|
| If ``True``, the output is modified to instead have a single point located
| at :attr:`center`.
|
| string
| Return or set the text string.
|
| width
| Return or set the width of the text.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
translate(surf: 'DataSet', center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0)) -> 'None'
Translate and orient a mesh to a new center and direction.
By default, the input mesh is considered centered at the origin
and facing in the x direction.
Parameters
----------
surf : pyvista.core.pointset.PolyData
Mesh to be translated and oriented.
center : tuple, optional, default: (0.0, 0.0, 0.0)
Center point to which the mesh should be translated.
direction : tuple, optional, default: (1.0, 0.0, 0.0)
Direction vector along which the mesh should be oriented.
DATA
ClassVar = typing.ClassVar
Special type construct to mark class variables.
An annotation wrapped in ClassVar indicates that a given
attribute is intended to be used as a class variable and
should not be set on instances of that class.
Usage::
class Starship:
stats: ClassVar[dict[str, int]] = {} # class variable
damage: int = 10 # instance variable
ClassVar accepts only types and cannot be further subscribed.
Note that ClassVar is not a class itself, and should not
be used with isinstance() or issubclass().
DOUBLE_PRECISION = 1
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
SINGLE_PRECISION = 0
TYPE_CHECKING = False
vtk_version_info = VTKVersionInfo(major=9, minor=6, micro=2)
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\geometric_sources.py
pyvista.get_array
Python Library Documentation: function get_array in module pyvista.core.utilities.arrays
get_array(mesh: 'DataSet | _vtk.vtkDataSet | _vtk.vtkTable', name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral | RowLiteral' = 'cell', err: 'bool' = False) -> 'pyvista_ndarray | None'
Search point, cell and field data for an array.
Parameters
----------
mesh : pyvista.DataSet
Dataset to get the array from.
name : str
The name of the array to get the range.
preference : str, default: "cell"
When scalars is specified, this is the preferred array type to
search for in the dataset. Must be either ``'point'``,
``'cell'``, or ``'field'``.
err : bool, default: False
Whether to throw an error if array is not present.
Returns
-------
output : pyvista.pyvista_ndarray | None
Requested array. Return ``None`` if there is no array
matching the ``name`` and ``err=False``.
pyvista.get_array_association
Python Library Documentation: function get_array_association in module pyvista.core.utilities.arrays
get_array_association(mesh: 'DataSet | _vtk.vtkDataSet | _vtk.vtkTable', name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral | RowLiteral' = 'cell', err: 'bool' = False) -> 'FieldAssociation'
Return the array association.
Parameters
----------
mesh : pyvista.DataSet
Dataset to get the array association from.
name : str
The name of the array.
preference : str, default: "cell"
When scalars is specified, this is the preferred array type to
search for in the dataset. Must be either ``'point'``,
``'cell'``, or ``'field'``.
err : bool, default: False
Boolean to control whether to throw an error if array is not
present.
Returns
-------
pyvista.core.utilities.arrays.FieldAssociation
Association of the array. If array is not present and ``err`` is
``False``, ``FieldAssociation.NONE`` is returned.
pyvista.get_ext
Python Library Documentation: function get_ext in module pyvista.core.utilities.fileio
get_ext(filename: 'str | Path') -> 'str'
Extract the extension of the filename.
For files with the .gz suffix, the previous extension is returned as well.
This is needed e.g. for the compressed NIFTI format (.nii.gz).
Parameters
----------
filename : str, Path
The filename from which to extract the extension.
Returns
-------
str
The extracted extension. For files with the .gz suffix, the previous
extension is returned as well.
pyvista.get_gpu_info
Python Library Documentation: function get_gpu_info in module pyvista.report
get_gpu_info()
Get all information about the GPU.
pyvista.get_mixed_cells
Python Library Documentation: function get_mixed_cells in module pyvista.core.utilities.cells
get_mixed_cells(vtkobj: 'UnstructuredGrid') -> 'dict[np.uint8, NumpyArray[int]]'
Create the cells dictionary from the given pyvista.UnstructuredGrid.
This functions creates a cells dictionary (see
create_mixed_cells), with a mapping vtk_type -> np.ndarray (int)
for fixed size cell types. The returned dictionary will have
arrays of size [N, D], where N is the number of cells and D is the
size of the cells for the given type (e.g. 3 for triangles).
.. versionchanged:: 0.46
An empty dict ``{}`` is returned instead of ``None`` if the input
is empty.
Parameters
----------
vtkobj : pyvista.UnstructuredGrid
The unstructured grid for which the cells dictionary should be computed.
Returns
-------
dict
Dictionary of cells.
Raises
------
ValueError
If vtkobj is not a pyvista.UnstructuredGrid, any of the
present cells are unsupported, or have dynamic cell sizes,
like VTK_POLYGON.
pyvista.get_reader
Python Library Documentation: function get_reader in module pyvista.core.utilities.reader
get_reader(filename, force_ext=None)
Get a reader for fine-grained control of reading data files.
Supported file types and Readers:
.. include:: /api/readers/readers_table.rst
Parameters
----------
filename : str, Path
The string path to the file to read.
force_ext : str, optional
An extension to force a specific reader to be chosen.
Returns
-------
pyvista.BaseReader
A subclass of :class:`pyvista.BaseReader` is returned based on file type.
Examples
--------
>>> import pyvista as pv
>>> from pyvista import examples
>>> from pathlib import Path
>>> filename = examples.download_human(load=False)
>>> Path(filename).name
'Human.vtp'
>>> reader = pv.get_reader(filename)
>>> reader
XMLPolyDataReader('...Human.vtp')
>>> mesh = reader.read()
>>> mesh
PolyData ...
>>> mesh.plot(color='lightblue')
pyvista.get_vtk_type
Python Library Documentation: function get_vtk_type in module pyvista.core.utilities.arrays
get_vtk_type(typ: 'npt.DTypeLike') -> 'int'
Look up the VTK type for a given numpy data type.
Corrects for string type mapping issues.
Parameters
----------
typ : numpy.dtype
Numpy data type.
Returns
-------
int
Integer type id specified in ``vtkType.h``.
pyvista.global_config
Python Library Documentation: Config in module pyvista.core.config object
class Config(_ConfigBase)
| Config() -> 'None'
|
| PyVista core configuration.
|
| Holds process-wide settings that affect ``pyvista.core`` behavior. The
| singleton instance is exposed as ``pyvista.global_config``. This is the
| sibling of ``pyvista.global_theme`` for plotting (rendering) settings.
|
| Examples
| --------
| Disable the default array-length check performed by :func:`pyvista.wrap`:
|
| >>> import pyvista as pv
| >>> pv.global_config.validate_on_wrap = False
| >>> pv.global_config.validate_on_wrap = True # restore default
|
| Method resolution order:
| Config
| _ConfigBase
| builtins.object
|
| Methods defined here:
|
| __init__(self) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| show_vtk_api
| Return or set whether VTK-inherited attributes appear in :func:`dir`.
|
| When ``False`` (the default), attributes inherited from VTK base
| classes are hidden from :func:`dir` and tab-completion on PyVista
| objects that wrap VTK types (data objects, :class:`~pyvista.Renderer`,
| :class:`~pyvista.Actor`, :class:`~pyvista.Property`, etc.). This keeps
| the public surface curated for data-science IDEs such as Positron's
| Variables pane and VS Code's Jupyter extension, and for IPython /
| Jupyter tab-completion. VTK methods remain fully callable regardless
| of this setting.
|
| When ``True``, the full VTK API is enumerated alongside the PyVista
| API, which is useful for VTK developers who want to discover the raw
| VTK method surface via introspection.
|
| .. warning::
|
| This option requires runtime inspection and does not work with all developer
| tools, e.g. it has no effect when using PyCharm. This is because it relies on
| calling the object's ``__dir__`` method for generating auto-completion
| suggestions. Tools like PyCharm that only use static analysis for
| auto-completion are therefore unaffected.
|
| Notes
| -----
| The snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| controlled separately by :func:`pyvista.vtk_snake_case`. When
| snake_case is not ``'allow'`` (the default), those names are hidden
| from :func:`dir` regardless of this setting, because accessing them
| would already raise ``PyVistaAttributeError``.
| Enabling snake_case surfaces the snake_case names in :func:`dir`;
| ``show_vtk_api`` only controls the CamelCase VTK API.
|
| .. versionadded:: 0.48
|
| Examples
| --------
| >>> import pyvista as pv
| >>> pv.global_config.show_vtk_api
| False
| >>> pv.global_config.show_vtk_api = True
| >>> pv.global_config.show_vtk_api = False # restore default
|
| validate_on_wrap
| Return or set whether :func:`pyvista.wrap` validates data arrays.
|
| When ``True`` (the default), :func:`pyvista.wrap` performs a cheap
| array-length sanity check on every VTK object it wraps and emits a
| :class:`~pyvista.InvalidMeshWarning` if any point or cell data array
| has a tuple count that does not match the dataset's point or cell
| count. Set to ``False`` to skip this check globally when the cost
| matters in tight loops and the caller trusts their inputs.
|
| Notes
| -----
| Per-call control is also available via the ``validate`` keyword on
| :func:`pyvista.wrap`, :func:`pyvista.read`, and
| :meth:`pyvista.BaseReader.read`. The per-call keyword takes
| precedence; this global setting is consulted only when the per-call
| keyword is left at its default ``None``.
|
| .. versionadded:: 0.48
|
| Examples
| --------
| >>> import pyvista as pv
| >>> pv.global_config.validate_on_wrap
| True
| >>> pv.global_config.validate_on_wrap = False
| >>> pv.global_config.validate_on_wrap = True # restore default
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from _ConfigBase:
|
| __eq__(self, other: 'object') -> 'bool'
| Return self==value.
|
| __getitem__(self, key: 'str') -> 'Any'
| Get a value via a key (backwards-compatible dict access).
|
| __setitem__(self, key: 'str', value: 'Any') -> 'None'
| Set a value via a key (backwards-compatible dict access).
|
| to_dict(self) -> 'dict[str, Any]'
| Return config parameters as a dictionary.
|
| Returns
| -------
| dict
| Mapping of public attribute name to its current value. Nested
| config objects are recursively serialized via their own
| ``to_dict``. Names listed in :attr:`_TO_DICT_SKIP` are omitted.
|
| ----------------------------------------------------------------------
| Class methods inherited from _ConfigBase:
|
| from_dict(dict_: 'dict[str, Any]') -> 'Self'
| Create an instance from a dictionary of attribute values.
|
| Parameters
| ----------
| dict_ : dict
| Mapping of public attribute name to value, as produced by
| :meth:`to_dict`. Nested config objects are recursively
| reconstructed via their own ``from_dict``.
|
| Returns
| -------
| Self
| New instance of ``cls`` populated from ``dict_``.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from _ConfigBase:
|
| __hash__ = None
pyvista.grid
Python Library Documentation: module pyvista.core.grid in pyvista.core
NAME
pyvista.core.grid - Sub-classes for :vtk:`vtkRectilinearGrid` and :vtk:`vtkImageData`.
CLASSES
pyvista.core.dataset.DataSet(pyvista.core.filters.data_set.DataSetFilters, pyvista.core.dataobject.DataObject)
Grid
ImageData(Grid, pyvista.core.filters.image_data.ImageDataFilters, vtkmodules.vtkCommonDataModel.vtkImageData)
RectilinearGrid(Grid, pyvista.core.filters.rectilinear_grid.RectilinearGridFilters, vtkmodules.vtkCommonDataModel.vtkRectilinearGrid)
class Grid(pyvista.core.dataset.DataSet)
| Grid(*args, **kwargs) -> '_T'
|
| A class full of common methods for non-pointset grids.
|
| Method resolution order:
| Grid
| pyvista.core.dataset.DataSet
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| builtins.object
|
| Methods defined here:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| to_hexahedra(self: 'Self') -> 'UnstructuredGrid'
| Convert voxels to hexahedra.
|
| Convert this mesh to :class:`~pyvista.UnstructuredGrid` with
| :attr:`~pyvista.CellType.HEXAHEDRON` cells. Equivalent to
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` except the output has
| hexahedra instead of :attr:`~pyvista.CellType.VOXEL` cells.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with :attr:`~pyvista.CellType.HEXAHEDRON` cells.
|
| Raises
| ------
| ValueError
| If the input is not 3-dimensional.
|
| See Also
| --------
| to_quads, to_tetrahedra
| pyvista.DataSet.cast_to_unstructured_grid
|
| Examples
| --------
| Convert a 3D :class:`~pyvista.ImageData` to hexahedra.
|
| >>> import pyvista as pv
| >>> image = pv.ImageData(dimensions=(2, 2, 2))
| >>> hexes = image.to_hexahedra()
| >>> hexes.distinct_cell_types == {pv.CellType.HEXAHEDRON}
| True
|
| to_quads(self: 'Self') -> 'UnstructuredGrid'
| Convert pixels to quads.
|
| Convert this mesh to :class:`~pyvista.UnstructuredGrid` with
| :attr:`~pyvista.CellType.QUAD` cells. Equivalent to
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` except the output has
| quads instead of :attr:`~pyvista.CellType.PIXEL` cells.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with :attr:`~pyvista.CellType.QUAD` cells.
|
| Raises
| ------
| ValueError
| If the input is not 2-dimensional.
|
| See Also
| --------
| to_hexahedra, to_tetrahedra
| pyvista.DataSet.cast_to_unstructured_grid
|
| Examples
| --------
| Convert a 2D :class:`~pyvista.ImageData` to quads.
|
| >>> import pyvista as pv
| >>> image = pv.ImageData(dimensions=(3, 2, 1))
| >>> quads = image.to_quads()
| >>> quads.distinct_cell_types == {pv.CellType.QUAD}
| True
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| dimensions
| Return the grid's dimensions.
|
| These are effectively the number of points along each of the
| three dataset axes.
|
| Returns
| -------
| tuple[int]
| Dimensions of the grid.
|
| Examples
| --------
| Create a uniform grid with dimensions ``(1, 2, 3)``.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(2, 3, 4))
| >>> grid.dimensions
| (2, 3, 4)
| >>> grid.plot(show_edges=True)
|
| Set the dimensions to ``(3, 4, 5)``
|
| >>> grid.dimensions = (3, 4, 5)
| >>> grid.plot(show_edges=True)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __init__(self: 'Self', *args, **kwargs) -> 'None'
| Initialize the common object.
|
| __repr__(self: 'Self') -> 'str'
| Return the object representation.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| __str__(self: 'Self') -> 'str'
| Return the object string representation.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
class ImageData(Grid, pyvista.core.filters.image_data.ImageDataFilters, vtkmodules.vtkCommonDataModel.vtkImageData)
| ImageData(*args, **kwargs) -> '_T'
|
| Models datasets with uniform spacing in the three coordinate directions.
|
| Can be initialized in one of several ways:
|
| - Create empty grid
| - Initialize from a :vtk:`vtkImageData` object
| - Initialize based on dimensions, cell spacing, and origin.
|
| .. versionchanged:: 0.33.0
| First argument must now be either a path or
| :vtk:`vtkImageData`. Use keyword arguments to specify the
| dimensions, spacing, and origin of the uniform grid.
|
| .. versionchanged:: 0.37.0
| The ``dims`` parameter has been renamed to ``dimensions``.
|
| Parameters
| ----------
| uinput : str | :vtk:`vtkImageData` | ImageData, optional
| Filename or dataset to initialize the uniform grid from. If
| set, remainder of arguments are ignored.
|
| dimensions : sequence[int], optional
| :attr:`dimensions` of the uniform grid.
|
| spacing : sequence[float], default: (1.0, 1.0, 1.0)
| :attr:`spacing` of the uniform grid in each dimension. Must be positive.
|
| origin : sequence[float], default: (0.0, 0.0, 0.0)
| :attr:`origin` of the uniform grid.
|
| deep : bool, default: False
| Whether to deep copy a :vtk:`vtkImageData` object. Keyword only.
|
| direction_matrix : RotationLike, optional
| The :attr:`direction_matrix` is a 3x3 matrix which controls the orientation of
| the image data.
|
| .. versionadded:: 0.45
|
| offset : int | VectorLike[int], default: (0, 0, 0)
| The offset defines the minimum :attr:`extent` of the image. Offset values
| can be positive or negative. In physical space, the offset is relative
| to the image's :attr:`origin`.
|
| .. versionadded:: 0.45
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| :ref:`create_uniform_grid_example`
|
| Examples
| --------
| Create an empty ImageData.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData()
|
| Initialize from a :vtk:`vtkImageData` object.
|
| >>> import vtk
| >>> vtkgrid = vtk.vtkImageData()
| >>> grid = pv.ImageData(vtkgrid)
|
| Initialize using just the grid dimensions and default
| spacing and origin. These must be keyword arguments.
|
| >>> grid = pv.ImageData(dimensions=(10, 10, 10))
|
| Initialize using dimensions and spacing.
|
| >>> grid = pv.ImageData(
| ... dimensions=(10, 10, 10),
| ... spacing=(2, 1, 5),
| ... )
|
| Initialize using dimensions, spacing, and an origin.
|
| >>> grid = pv.ImageData(
| ... dimensions=(10, 10, 10),
| ... spacing=(2, 1, 5),
| ... origin=(10, 35, 50),
| ... )
|
| Initialize from another ImageData.
|
| >>> grid = pv.ImageData(
| ... dimensions=(10, 10, 10),
| ... spacing=(2, 1, 5),
| ... origin=(10, 35, 50),
| ... )
| >>> grid_from_grid = pv.ImageData(grid)
| >>> grid_from_grid == grid
| True
|
| Method resolution order:
| ImageData
| Grid
| pyvista.core.dataset.DataSet
| pyvista.core.filters.image_data.ImageDataFilters
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkImageData
| vtkmodules.vtkCommonDataModel.vtkCartesianGrid
| vtkmodules.vtkCommonDataModel.vtkDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __getitem__(self, key: "tuple[str, Literal['cell', 'point', 'field']] | str | tuple[int, int, int]") -> 'ImageData | pyvista_ndarray'
| Search for a data array or slice with IJK indexing.
|
| __init__(self: 'Self', uinput: 'ImageData | str | Path | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'VectorLike[float]' = (1.0, 1.0, 1.0), origin: 'VectorLike[float]' = (0.0, 0.0, 0.0), deep: 'bool' = False, direction_matrix: 'RotationLike | None' = None, offset: 'int | VectorLike[int] | None' = None, *, validate: 'bool | _NestedMeshValidationFields' = False) -> 'None'
| Initialize the uniform grid.
|
| __repr__(self: 'Self') -> 'str'
| Return the default representation.
|
| __str__(self: 'Self') -> 'str'
| Return the default str representation.
|
| cast_to_rectilinear_grid(self: 'Self') -> 'RectilinearGrid'
| Cast this uniform grid to a rectilinear grid.
|
| Returns
| -------
| pyvista.RectilinearGrid
| This uniform grid as a rectilinear grid.
|
| cast_to_structured_grid(self: 'Self') -> 'StructuredGrid'
| Cast this image data to a :class:`~pyvista.StructuredGrid`.
|
| .. note::
|
| Casting converts :class:`~pyvista.CellType.PIXEL` cells to
| :class:`~pyvista.CellType.QUAD` cells for 2D inputs, and
| :class:`~pyvista.CellType.VOXEL` cells to :class:`~pyvista.CellType.HEXAHEDRON` cells
| for 3D inputs. To preserve cell type, use
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` instead.
|
| Returns
| -------
| pyvista.StructuredGrid
| This grid as a structured grid.
|
| to_tetrahedra(self, tetra_per_cell: 'int' = 5, mixed: 'str | Sequence[int] | bool' = False, pass_cell_ids: 'bool' = True, pass_data: 'bool' = True, progress_bar: 'bool' = False) from pyvista.core.filters.rectilinear_grid.RectilinearGridFilters
| Create a tetrahedral mesh structured grid.
|
| Parameters
| ----------
| tetra_per_cell : int, default: 5
| The number of tetrahedrons to divide each cell into. Can be
| either ``5``, ``6``, or ``12``. If ``mixed=True``, this value is
| overridden.
|
| mixed : str, bool, sequence, default: False
| When set, subdivides some cells into 5 and some cells into 12. Set
| to ``True`` to use the active cell scalars of the
| :class:`pyvista.RectilinearGrid` to be either 5 or 12 to
| determining the number of tetrahedra to generate per cell.
|
| When a sequence, uses these values to subdivide the cells. When a
| string uses a cell array rather than the active array to determine
| the number of tetrahedra to generate per cell.
|
| pass_cell_ids : bool, default: True
| Set to ``True`` to make the tetrahedra have scalar data indicating
| which cell they came from in the original
| :class:`pyvista.RectilinearGrid`. The name of this array is
| ``'vtkOriginalCellIds'`` within the ``cell_data``.
|
| pass_data : bool, default: True
| Set to ``True`` to make the tetrahedra mesh have the cell data from
| the original :class:`pyvista.RectilinearGrid`. This uses
| ``pass_cell_ids=True`` internally. If ``True``, ``pass_cell_ids``
| will also be set to ``True``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the tetrahedral cells.
|
| Examples
| --------
| Divide a rectangular grid into tetrahedrons. Each cell contains by
| default 5 tetrahedrons.
|
| First, create and plot the grid.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 2)
| >>> yrng = np.linspace(0, 1, 2)
| >>> zrng = np.linspace(0, 2, 3)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> grid.plot()
|
| Now, generate the tetrahedra plot in the exploded view of the cell.
|
| >>> tet_grid = grid.to_tetrahedra()
| >>> tet_grid.explode(factor=0.5).plot(show_edges=True)
|
| Take the same grid but divide the first cell into 5 cells and the other
| cell into 12 tetrahedrons per cell.
|
| >>> tet_grid = grid.to_tetrahedra(mixed=[5, 12])
| >>> tet_grid.explode(factor=0.5).plot(show_edges=True)
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| x
| Return all the X points.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(2, 2, 2))
| >>> grid.x
| array([0., 1., 0., 1., 0., 1., 0., 1.])
|
| y
| Return all the Y points.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(2, 2, 2))
| >>> grid.y
| array([0., 0., 1., 1., 0., 0., 1., 1.])
|
| z
| Return all the Z points.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(2, 2, 2))
| >>> grid.z
| array([0., 0., 0., 0., 1., 1., 1., 1.])
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| direction_matrix
| Set or get the direction matrix.
|
| The direction matrix is a 3x3 matrix which controls the orientation of the
| image data.
|
| .. versionadded:: 0.45
|
| Returns
| -------
| np.ndarray
| Direction matrix as a 3x3 NumPy array.
|
| extent
| Return or set the extent of the ImageData.
|
| The extent is simply the first and last indices for each of the three axes.
| It encodes information about the image's :attr:`offset` and :attr:`dimensions`.
|
| Examples
| --------
| Create a ``ImageData`` and show its extent.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(10, 10, 10))
| >>> grid.extent
| (0, 9, 0, 9, 0, 9)
|
| >>> grid.extent = (2, 5, 2, 5, 2, 5)
| >>> grid.extent
| (2, 5, 2, 5, 2, 5)
|
| Note how this also modifies the grid's :attr:`offset`, :attr:`dimensions`,
| and :attr:`bounds`. Since we use default spacing of 1 here, the bounds
| match the extent exactly.
|
| >>> grid.offset
| (2, 2, 2)
|
| >>> grid.dimensions
| (4, 4, 4)
|
| >>> grid.bounds
| BoundsTuple(x_min = 2.0,
| x_max = 5.0,
| y_min = 2.0,
| y_max = 5.0,
| z_min = 2.0,
| z_max = 5.0)
|
| index_to_physical_matrix
| Return or set 4x4 matrix to transform index space (ijk) to physical space (xyz).
|
| .. note::
| Setting this property modifies the object's :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and :class:`~pyvista.ImageData.direction_matrix`
| properties.
|
| .. versionadded:: 0.45
|
| Returns
| -------
| np.ndarray
| 4x4 transformation matrix.
|
| offset
| Return or set the index offset of the ImageData.
|
| The offset is simply the first indices for each of the three axes
| and defines the minimum :attr:`extent` of the image. Offset values
| can be positive or negative. In physical space, the offset is relative
| to the image's :attr:`origin`.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| Create a ``ImageData`` and show that the offset is zeros by default.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(10, 10, 10))
| >>> grid.offset
| (0, 0, 0)
|
| The offset defines the minimum extent.
|
| >>> grid.extent
| (0, 9, 0, 9, 0, 9)
|
| Set the offset to a new value for all axes.
|
| >>> grid.offset = 2
| >>> grid.offset
| (2, 2, 2)
|
| Show the extent again. Note how all values have increased by the offset value.
|
| >>> grid.extent
| (2, 11, 2, 11, 2, 11)
|
| Set the offset for each axis separately and show the extent again.
|
| >>> grid.offset = (-1, -2, -3)
| >>> grid.extent
| (-1, 8, -2, 7, -3, 6)
|
| origin
| Return the origin of the grid (bottom southwest corner).
|
| Examples
| --------
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> grid.origin
| (0.0, 0.0, 0.0)
|
| Show how the origin is in the bottom "southwest" corner of the
| ImageData.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(grid, show_edges=True)
| >>> _ = pl.add_axes_at_origin(ylabel=None)
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| Set the origin to ``(1, 1, 1)`` and show how this shifts the
| ImageData.
|
| >>> grid.origin = (1, 1, 1)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(grid, show_edges=True)
| >>> _ = pl.add_axes_at_origin(ylabel=None)
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| physical_to_index_matrix
| Return or set 4x4 matrix to transform from physical space (xyz) to index space (ijk).
|
| .. note::
| Setting this property modifies the object's :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and :class:`~pyvista.ImageData.direction_matrix`
| properties.
|
| .. versionadded:: 0.45
|
| Returns
| -------
| np.ndarray
| 4x4 transformation matrix.
|
| points
| Build a copy of the implicitly defined points as a numpy array.
|
| Returns
| -------
| numpy.ndarray
| Array of points representing the image data.
|
| Notes
| -----
| The ``points`` for a :class:`pyvista.ImageData` cannot be set.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(2, 2, 2))
| >>> grid.points
| array([[0., 0., 0.],
| [1., 0., 0.],
| [0., 1., 0.],
| [1., 1., 0.],
| [0., 0., 1.],
| [1., 0., 1.],
| [0., 1., 1.],
| [1., 1., 1.]])
|
| spacing
| Return or set the spacing for each axial direction.
|
| Notes
| -----
| Spacing must be non-negative. While VTK accepts negative
| spacing, this results in unexpected behavior. See:
| https://github.com/pyvista/pyvista/issues/1967
|
| Examples
| --------
| Create a 5 x 5 x 5 uniform grid.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> grid.spacing
| (1.0, 1.0, 1.0)
| >>> grid.plot(show_edges=True)
|
| Modify the spacing to ``(1, 2, 3)``
|
| >>> grid.spacing = (1, 2, 3)
| >>> grid.plot(show_edges=True)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| ----------------------------------------------------------------------
| Methods inherited from Grid:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| to_hexahedra(self: 'Self') -> 'UnstructuredGrid'
| Convert voxels to hexahedra.
|
| Convert this mesh to :class:`~pyvista.UnstructuredGrid` with
| :attr:`~pyvista.CellType.HEXAHEDRON` cells. Equivalent to
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` except the output has
| hexahedra instead of :attr:`~pyvista.CellType.VOXEL` cells.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with :attr:`~pyvista.CellType.HEXAHEDRON` cells.
|
| Raises
| ------
| ValueError
| If the input is not 3-dimensional.
|
| See Also
| --------
| to_quads, to_tetrahedra
| pyvista.DataSet.cast_to_unstructured_grid
|
| Examples
| --------
| Convert a 3D :class:`~pyvista.ImageData` to hexahedra.
|
| >>> import pyvista as pv
| >>> image = pv.ImageData(dimensions=(2, 2, 2))
| >>> hexes = image.to_hexahedra()
| >>> hexes.distinct_cell_types == {pv.CellType.HEXAHEDRON}
| True
|
| to_quads(self: 'Self') -> 'UnstructuredGrid'
| Convert pixels to quads.
|
| Convert this mesh to :class:`~pyvista.UnstructuredGrid` with
| :attr:`~pyvista.CellType.QUAD` cells. Equivalent to
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` except the output has
| quads instead of :attr:`~pyvista.CellType.PIXEL` cells.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with :attr:`~pyvista.CellType.QUAD` cells.
|
| Raises
| ------
| ValueError
| If the input is not 2-dimensional.
|
| See Also
| --------
| to_hexahedra, to_tetrahedra
| pyvista.DataSet.cast_to_unstructured_grid
|
| Examples
| --------
| Convert a 2D :class:`~pyvista.ImageData` to quads.
|
| >>> import pyvista as pv
| >>> image = pv.ImageData(dimensions=(3, 2, 1))
| >>> quads = image.to_quads()
| >>> quads.distinct_cell_types == {pv.CellType.QUAD}
| True
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Grid:
|
| dimensions
| Return the grid's dimensions.
|
| These are effectively the number of points along each of the
| three dataset axes.
|
| Returns
| -------
| tuple[int]
| Dimensions of the grid.
|
| Examples
| --------
| Create a uniform grid with dimensions ``(1, 2, 3)``.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(2, 3, 4))
| >>> grid.dimensions
| (2, 3, 4)
| >>> grid.plot(show_edges=True)
|
| Set the dimensions to ``(3, 4, 5)``
|
| >>> grid.dimensions = (3, 4, 5)
| >>> grid.plot(show_edges=True)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.image_data.ImageDataFilters:
|
| cells_to_points(self: 'ImageData', scalars: 'str | None' = None, *, dimensionality: "VectorLike[bool] | Literal[0, 1, 2, 3, '0D', '1D', '2D', '3D', 'preserve']" = 'preserve', copy: 'bool' = True)
| Re-mesh image data from a cell-based to a point-based representation.
|
| This filter changes how image data is represented. Data represented as cells
| at the input is re-meshed into an alternative representation as points at the
| output. Only the :class:`~pyvista.ImageData` container is modified so that
| the number of input cells equals the number of output points. The re-meshing is
| otherwise lossless in the sense that cell data at the input is passed through
| unmodified and stored as point data at the output. Any point data at the input is
| ignored and is not used by this filter.
|
| To change the image data's representation, the input cell centers are used to
| represent the output points. This has the effect of "shrinking" the
| input image dimensions by one along each axis (i.e. half the cell width on each
| side). For example, an image with 101 points and 100 cells along an axis at the
| input will have 100 points and 99 cells at the output. If the input has 1mm
| spacing, the axis size will also decrease from 100mm to 99mm.
|
| Since filters may be inherently cell-based (e.g. some :class:`~pyvista.DataSetFilters`)
| or may operate on point data exclusively (e.g. most :class:`~pyvista.ImageDataFilters`),
| re-meshing enables the same data to be used with either kind of filter while
| ensuring the input data to those filters has the appropriate representation.
| This filter is also useful when plotting image data to achieve a desired visual
| effect, such as plotting images as points instead of as voxel cells.
|
| .. note::
| Only the input's :attr:`~pyvista.ImageData.dimensions`, and
| :attr:`~pyvista.ImageData.origin` are modified by this filter. Other spatial
| properties such as :attr:`~pyvista.ImageData.spacing` and
| :attr:`~pyvista.ImageData.direction_matrix` are not affected.
|
| .. versionadded:: 0.44.0
|
| See Also
| --------
| points_to_cells
| Inverse of this filter to represent points as cells.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample cell data as point data without modifying the container.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample point data as cell data without modifying the container.
|
| Parameters
| ----------
| scalars : str, optional
| Name of cell data scalars to pass through to the output as point data. Use
| this parameter to restrict the output to only include the specified array.
| By default, all cell data arrays at the input are passed through as point
| data at the output.
|
| dimensionality : VectorLike[bool], Literal[0, 1, 2, 3, "0D", "1D", "2D", "3D", "preserve"]
| Control which dimensions will be modified by the filter.
| ``'preserve'`` is used by default.
|
| - Can be specified as a sequence of 3 boolean to allow modification on a per
| dimension basis.
| - ``0`` or ``'0D'``: convenience alias to output a 0D ImageData with
| dimensions ``(1, 1, 1)``. Only valid for 0D inputs.
| - ``1`` or ``'1D'``: convenience alias to output a 1D ImageData where
| exactly one dimension is greater than one, e.g. ``(>1, 1, 1)``. Only valid
| for 0D or 1D inputs.
| - ``2`` or ``'2D'``: convenience alias to output a 2D ImageData where
| exactly two dimensions are greater than one, e.g. ``(>1, >1, 1)``. Only
| valid for 0D, 1D, or 2D inputs.
| - ``3`` or ``'3D'``: convenience alias to output a 3D ImageData, where all
| three dimensions are greater than one, e.g. ``(>1, >1, >1)``. Valid for
| any 0D, 1D, 2D, or 3D inputs.
| - ``'preserve'`` (default): convenience alias to not modify singleton
| dimensions.
|
| .. note::
| This filter does not modify singleton dimensions with ``dimensionality``
| set as ``'preserve'`` by default.
|
| copy : bool, default: True
| Copy the input cell data before associating it with the output point data.
| If ``False``, the input and output will both refer to the same data array(s).
|
| Returns
| -------
| pyvista.ImageData
| Image with a point-based representation.
|
| Examples
| --------
| Load an image with cell data.
|
| >>> from pyvista import examples
| >>> image = examples.load_uniform()
|
| Show the current properties and cell arrays of the image.
|
| >>> image
| ImageData (...)
| N Cells: 729
| N Points: 1000
| X Bounds: 0.000e+00, 9.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| Dimensions: 10, 10, 10
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 2
|
| >>> image.cell_data.keys()
| ['Spatial Cell Data']
|
| Re-mesh the cells and cell data as points and point data.
|
| >>> points_image = image.cells_to_points()
|
| Show the properties and point arrays of the re-meshed image.
|
| >>> points_image
| ImageData (...)
| N Cells: 512
| N Points: 729
| X Bounds: 5.000e-01, 8.500e+00
| Y Bounds: 5.000e-01, 8.500e+00
| Z Bounds: 5.000e-01, 8.500e+00
| Dimensions: 9, 9, 9
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> points_image.point_data.keys()
| ['Spatial Cell Data']
|
| Observe that:
|
| - The input cell array is now a point array
| - The output has one less array (the input point data is ignored)
| - The dimensions have decreased by one
| - The bounds have decreased by half the spacing
| - The output ``N Points`` equals the input ``N Cells``
|
| See :ref:`image_representations_example` for more examples using this filter.
|
| close(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Perform morphological closing on continuous or binary data.
|
| Closing is a :meth:`dilation <dilate>` followed by an :meth:`erosion <erode>`.
| It is used to fill small holes/gaps while preserving the shape and size of larger objects.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are closed, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary closing or continuous closing is used. Refer to
| :meth:`dilate` and/or :meth:`erode` for details about using this keyword.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been closed.
|
| See Also
| --------
| open, erode, dilate
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| Load a binary image: :func:`~pyvista.examples.downloads.download_yinyang()`.
|
| >>> from pyvista import examples
| >>> im = examples.download_yinyang()
|
| Use ``close`` with a relatively small kernel to fill the top black edge of the yinyang.
|
| >>> closed = im.close(kernel_size=5)
| >>> kwargs = dict(
| ... cmap='grey',
| ... lighting=False,
| ... cpos='xy',
| ... zoom='tight',
| ... show_axes=False,
| ... show_scalar_bar=False,
| ... )
| >>> closed.plot(**kwargs)
|
| Use a much larger kernel to also fill the small black circle.
|
| >>> closed = im.close(kernel_size=25)
| >>> closed.plot(**kwargs)
|
| Since closing is the inverse of opening, we can alternatively use :meth:`open` to
| fill the white foreground values instead of the black background.
|
| >>> opened = im.open(kernel_size=25)
| >>> opened.plot(**kwargs)
|
| concatenate(self: 'ImageData', images: 'ImageData | Sequence[ImageData]', axis: '_AxisOptions | None' = None, *, mode: '_ConcatenateModeOptions | None' = None, dtype_policy: '_ConcatenateDTypePolicyOptions | None' = None, component_policy: '_ConcatenateComponentPolicyOptions | None' = None, background_value: 'float | VectorLike[float]' = 0.0, resample_kwargs: 'dict[str, Any] | None' = None)
| Combine multiple images into one.
|
| This filter uses :vtk:`vtkImageAppend` to combine multiple images. By default, images are
| concatenated along the specified ``axis``, and all images must have:
|
| #. identical dimensions except along the specified ``axis``,
| #. the same scalar dtype, and
| #. the same number of scalar components.
|
| Use ``mode`` for cases with mismatched dimensions, ``dtype_policy`` for cases with
| mismatched dtypes, and/or ``component_policy`` for cases with mismatched scalar components.
|
| The output has the same :attr:`~pyvista.ImageData.origin` and
| :attr:`~pyvista.ImageData.spacing` as the first input. The origin and spacing of all other
| inputs are ignored.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| images : ImageData | Sequence[ImageData]
| The input image(s) to concatenate. The default active scalars are used for all images.
|
| axis : int | str, default: 'x'
| Axis along which the images are concatenated:
|
| - ``0`` or ``'x'``: x-axis
| - ``1`` or ``'y'``: y-axis
| - ``2`` or ``'z'``: z-axis
|
| mode : str, default: 'strict'
| Concatenation mode to use. This determines how images are placed in the output. All
| modes operate along the specified ``axis`` except for ``'preserve-extents'``.
| Specify one of:
|
| - ``'strict'``: all images must have identical dimensions except along the specified
| ``axis``.
| - ``'resample-off-axis'``: :meth:`resample` off-axis dimensions of concatenated images
| to match the input. The on-axis dimension is `not` resampled.
| - ``'resample-match'``: :meth:`resample` all dimensions of concatenated images
| to match the input dimensions exactly. This is similar to ``'resample-off-axis'``,
| except the on-axis dimension is `also` resampled.
| - ``'resample-proportional'``: :meth:`resample` concatenated images proportionally to
| preserve their aspect ratio(s).
| - ``'crop-off-axis'``: :meth:`crop` off-axis dimensions of concatenated images
| to match the input. The on-axis dimension is `not` cropped.
| - ``'crop-match'``: Use :meth:`crop` to center-crop concatenated images such that
| their dimensions match the input dimensions exactly. This is similar to
| ``'crop-off-axis'``, except the on-axis dimension is `also` cropped.
| - ``'preserve-extents'``: the extents of all images are preserved and used to place the
| images in the output. The whole extent of the output is the union of the input whole
| extents. The origin and spacing is taken from the first input. ``axis`` is not used
| by this mode.
|
| .. note::
| Images may be padded with ``background_value`` in some cases when there are
| mismatched dimensions.
|
| dtype_policy : 'strict' | 'promote' | 'match', default: 'strict'
| - ``'strict'``: Do not cast any scalar array dtypes. All images being concatenated must
| have the same dtype, else a ``TypeError`` is raised.
| - ``'promote'``: Use :func:`numpy.result_type` to compute the dtype of the output
| image scalars. This option safely casts all input arrays to a common dtype before
| concatenating.
| - ``'match'``: Cast all array dtypes to match the input's dtype. This casting is
| unsafe as it may downcast values and lose precision.
|
| component_policy : 'strict' | 'promote_rgba', default: 'strict'
| - ``'strict'``: Do not modify the number of components of any scalars. All images being
| concatenated must have the same number of components, else a ``ValueError`` is
| raised.
| - ``'promote_rgba'``: Increase the number of components if necessary. Grayscale scalars
| with one component may be promoted to RGB scalars by duplicating values,
| and RGB scalars may be promoted to RGBA scalars by including an opacity component.
| For integer dtypes, the opacity is set to the max int representable by the dtype;
| for floats it is set to ``1.0``.
|
| background_value : float | VectorLike[float], default: 0
| Value or multi-component vector to use as background. The output may be padded with
| this value for some ``modes`` when there are mismatched dimensions.
|
| resample_kwargs : dict, optional
| Keyword arguments passed to :meth:`resample` when using ``'resample-off-axis'`` or
| ``'resample-proportional'`` modes. Specify ``interpolation``, ``border_mode`` or
| ``anti_aliasing`` options.
|
| Returns
| -------
| ImageData
| The concatenated image.
|
| Examples
| --------
| .. pyvista-plot::
| :force_static:
|
| Load a 2D image: :func:`~pyvista.examples.downloads.download_beach`.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beach = examples.download_beach()
|
| Use :meth:`select_values` to make a second version with white values converted to black
| to distinguish it from the original.
|
| >>> white = [255, 255, 255]
| >>> black = [0, 0, 0]
| >>> beach_black = beach.select_values(white, fill_value=black, invert=True)
|
| Concatenate them along the x-axis.
|
| >>> concatenated = beach.concatenate(beach_black, axis='x')
| >>> plot_kwargs = dict(
| ... rgb=True,
| ... lighting=False,
| ... cpos='xy',
| ... zoom='tight',
| ... show_axes=False,
| ... show_scalar_bar=False,
| ... )
| >>> concatenated.plot(**plot_kwargs)
|
| Concatenate them along the y-axis.
|
| >>> concatenated = beach.concatenate(beach_black, axis='y')
| >>> concatenated.plot(**plot_kwargs)
|
| By default, concatenation requires that all off-axis dimensions match the input. Use
| the ``mode`` keyword to enable concatenation with mismatched dimensions.
|
| Load a second 2D image with different dimensions:
| :func:`~pyvista.examples.downloads.download_bird`.
|
| >>> bird = examples.download_bird()
| >>> bird.dimensions
| (458, 342, 1)
| >>> beach.dimensions
| (100, 100, 1)
|
| Concatenate using ``'resample-proportional'`` mode to preserve the aspect ratio of the
| concatenated image. Linear interpolation with antialiasing is used to avoid sampling
| artifacts.
|
| >>> resample_kwargs = {'interpolation': 'linear', 'anti_aliasing': True}
| >>> concatenated = beach.concatenate(
| ... bird, mode='resample-proportional', resample_kwargs=resample_kwargs
| ... )
| >>> concatenated.dimensions
| (233, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'resample-proportional'`` again but concontenate along the z-axis instead. The
| ``bird``'s aspect ratio is preserved and padded with zeros so that it can be stacked
| on top of ``beach``.
|
| >>> concatenated = beach.concatenate(
| ... bird,
| ... axis='z',
| ... mode='resample-proportional',
| ... resample_kwargs=resample_kwargs,
| ... )
| >>> concatenated.dimensions
| (100, 100, 2)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'resample-off-axis'`` to only resample off-axis dimensions. This option may
| distort the image.
|
| >>> concatenated = beach.concatenate(
| ... bird, mode='resample-off-axis', resample_kwargs=resample_kwargs
| ... )
| >>> concatenated.dimensions
| (558, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'resample-match'`` to resample all dimensions to match the input exactly. This
| option may also distort the image.
|
| >>> concatenated = beach.concatenate(
| ... bird, mode='resample-match', resample_kwargs=resample_kwargs
| ... )
| >>> concatenated.dimensions
| (200, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use the ``'preserve-extents'`` mode. Using this mode naively may not produce the
| desired result, e.g. if we concatenate ``beach`` with ``bird``, the ``beach`` image is
| completely overwritten since their :attr:`~pyvista.ImageData.extent` fully overlap.
|
| >>> beach.extent
| (0, 99, 0, 99, 0, 0)
| >>> bird.extent
| (0, 457, 0, 341, 0, 0)
|
| >>> concatenated = beach.concatenate(bird, mode='preserve-extents')
| >>> concatenated.extent
| (0, 457, 0, 341, 0, 0)
| >>> concatenated.plot(**plot_kwargs)
|
| Set the ``beach`` :attr:`~pyvista.ImageData.offset` so that there is only partial
| overlap instead.
|
| >>> beach.offset = (-50, -50, 0)
| >>> beach.extent
| (-50, 49, -50, 49, 0, 0)
|
| >>> concatenated = beach.concatenate(bird, mode='preserve-extents')
| >>> concatenated.extent
| (-50, 457, -50, 341, 0, 0)
| >>> concatenated.plot(**plot_kwargs)
|
| Reverse the concatenation order, and use a green background value.
|
| >>> green = pv.Color('green').int_rgb
| >>> concatenated = bird.concatenate(
| ... beach, mode='preserve-extents', background_value=green
| ... )
| >>> concatenated.extent
| (-50, 457, -50, 341, 0, 0)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'crop-off-axis'`` to only crop off-axis dimensions.
|
| >>> concatenated = beach.concatenate(bird, mode='crop-off-axis')
| >>> concatenated.dimensions
| (558, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Reverse the concatenation order.
|
| >>> concatenated = bird.concatenate(beach, mode='crop-off-axis')
| >>> concatenated.dimensions
| (558, 342, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Use ``'crop-match'`` to center-crop the images to match the input's
| dimensions.
|
| >>> concatenated = beach.concatenate(bird, mode='crop-match')
| >>> concatenated.dimensions
| (200, 100, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Reverse the concatenation order, and use a grey background value.
|
| >>> concatenated = bird.concatenate(
| ... beach, mode='crop-match', background_value=128
| ... )
| >>> concatenated.dimensions
| (558, 342, 1)
| >>> concatenated.plot(**plot_kwargs)
|
| Load a binary image: :func:`~pyvista.examples.downloads.download_yinyang()`.
|
| >>> yinyang = examples.download_yinyang()
|
| Use ``component_policy`` to concatenate grayscale images with RGB(A) images.
|
| >>> concatenated = yinyang.concatenate(
| ... beach, mode='resample-proportional', component_policy='promote_rgba'
| ... )
| >>> concatenated.plot(**plot_kwargs)
|
| The grayscale portion of the image is promoted to RGB in this case and the entire
| image has 3 components:
|
| >>> concatenated.active_scalars.shape
| (292068, 3)
|
| contour_labeled(self, n_labels: 'int | None' = None, smoothing: 'bool' = False, smoothing_num_iterations: 'int' = 50, smoothing_relaxation_factor: 'float' = 0.5, smoothing_constraint_distance: 'float' = 1, output_mesh_type: "Literal['quads', 'triangles']" = 'quads', output_style: "Literal['default', 'boundary']" = 'default', scalars: 'str | None' = None, progress_bar: 'bool' = False) -> 'pv.PolyData'
| Generate labeled contours from 3D label maps.
|
| SurfaceNets algorithm is used to extract contours preserving sharp
| boundaries for the selected labels from the label maps.
| Optionally, the boundaries can be smoothened to reduce the staircase
| appearance in case of low resolution input label maps.
|
| This filter requires that the :class:`ImageData` has integer point
| scalars, such as multi-label maps generated from image segmentation.
|
| .. note::
| Requires ``vtk>=9.3.0``.
|
| .. deprecated:: 0.45
| This filter produces unexpected results and is deprecated.
| Use :meth:`~pyvista.ImageDataFilters.contour_labels` instead.
| See https://github.com/pyvista/pyvista/issues/5981 for details.
|
| To replicate the default behavior from this filter, call `contour_labels`
| with the following arguments:
|
| .. code-block:: python
|
| image.contour_labels(
| boundary_style='strict_external', # old filter strictly uses external polygons
| smoothing=False, # old filter does not apply smoothing
| output_mesh_type='quads', # old filter generates quads
| pad_background=False, # old filter generates open surfaces at input edges
| orient_faces=False, # old filter does not orient faces
| simplify_output=False, # old filter returns multi-component scalars
| )
|
| Parameters
| ----------
| n_labels : int, optional
| Number of labels to be extracted (all are extracted if None is given).
|
| smoothing : bool, default: False
| Apply smoothing to the meshes.
|
| smoothing_num_iterations : int, default: 50
| Number of smoothing iterations.
|
| smoothing_relaxation_factor : float, default: 0.5
| Relaxation factor of the smoothing.
|
| smoothing_constraint_distance : float, default: 1
| Constraint distance of the smoothing.
|
| output_mesh_type : str, default: 'quads'
| Type of the output mesh. Must be either ``'quads'``, or ``'triangles'``.
|
| output_style : str, default: 'default'
| Style of the output mesh. Must be either ``'default'`` or ``'boundary'``.
| When ``'default'`` is specified, the filter produces a mesh with both
| interior and exterior polygons. When ``'boundary'`` is selected, only
| polygons on the border with the background are produced (without interior
| polygons). Note that style ``'selected'`` is currently not implemented.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| :class:`pyvista.PolyData` Labeled mesh with the segments labeled.
|
| References
| ----------
| Sarah F. Frisken, SurfaceNets for Multi-Label Segmentations with Preservation
| of Sharp Boundaries, Journal of Computer Graphics Techniques (JCGT), vol. 11,
| no. 1, 34-54, 2022. Available online http://jcgt.org/published/0011/01/03/
|
| https://www.kitware.com/really-fast-isocontouring/
|
| Examples
| --------
| See :ref:`contouring_example` for a full example using this filter.
|
| See Also
| --------
| pyvista.DataSetFilters.contour
| Generalized contouring method which uses MarchingCubes or FlyingEdges.
|
| pyvista.DataSetFilters.pack_labels
| Function used internally by SurfaceNets to generate contiguous label data.
|
| contour_labels(self: 'ImageData', boundary_style: "Literal['external', 'internal', 'all', 'strict_external']" = 'external', *, background_value: 'int' = 0, select_inputs: 'int | VectorLike[int] | None' = None, select_outputs: 'int | VectorLike[int] | None' = None, pad_background: 'bool' = True, output_mesh_type: "Literal['quads', 'triangles'] | None" = None, scalars: 'str | None' = None, orient_faces: 'bool | None' = None, simplify_output: 'bool | None' = None, smoothing: 'bool' = True, smoothing_iterations: 'int' = 16, smoothing_relaxation: 'float' = 0.5, smoothing_distance: 'float | None' = None, smoothing_scale: 'float' = 1.0, progress_bar: 'bool' = False) -> 'PolyData'
| Generate surface contours from 3D image label maps.
|
| This filter uses :vtk:`vtkSurfaceNets3D`
| to extract polygonal surface contours from non-continuous label maps, which
| corresponds to discrete regions in an input 3D image (i.e., volume). It is
| designed to generate surfaces from image point data, e.g. voxel point
| samples from 3D medical images, though images with cell data are also supported.
|
| The generated surface is smoothed using a constrained smoothing filter, which
| may be fine-tuned to control the smoothing process. Optionally, smoothing may
| be disabled to generate a staircase-like surface.
|
| The output surface includes a two-component cell data array ``'boundary_labels'``.
| The array indicates the labels/regions on either side of the polygons composing
| the output. The array's values are structured as follows:
|
| External boundary values
|
| Polygons between a foreground region and the background have the
| form ``[foreground, background]``.
|
| E.g. ``[1, 0]`` for the boundary between region ``1`` and background ``0``.
|
| Internal boundary values
|
| Polygons between two connected foreground regions are sorted in ascending order.
|
| E.g. ``[1, 2]`` for the boundary between regions ``1`` and ``2``.
|
| By default, this filter returns ``'external'`` contours only. Optionally,
| only the ``'internal'`` contours or ``'all'`` contours (i.e. internal and
| external) may be returned.
|
| .. note::
|
| This filter requires VTK version ``9.3.0`` or greater.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| boundary_style : 'external' | 'internal' | 'all' | 'strict_external', default: 'external'
| Style of boundary polygons to generate. ``'internal'`` polygons are generated
| between two connected foreground regions. ``'external'`` polygons are
| generated between foreground and background regions. ``'all'`` includes
| both internal and external boundary polygons.
|
| These styles are generated such that ``internal + external = all``.
| Internally, the filter computes all boundary polygons by default and
| then removes any undesired polygons in post-processing.
| This improves the quality of the output, but can negatively affect the
| filter's performance since all boundaries are always initially computed.
|
| The ``'strict_external'`` style can be used as a fast alternative to
| ``'external'``. This style `strictly` generates external polygons and does
| not compute or consider internal boundaries. This computation is fast, but
| also results in jagged, non-smooth boundaries between regions. The
| ``select_inputs`` and ``select_outputs`` options cannot be used with this
| style.
|
| background_value : int, default: 0
| Background value of the input image. All other values are considered
| as foreground.
|
| select_inputs : int | VectorLike[int], default: None
| Specify label ids to include as inputs to the filter. Labels that are not
| selected are removed from the input *before* generating the surface. By
| default, all label ids are used.
|
| Since the smoothing operation occurs across selected input regions, using
| this option to filter the input can result in smoother and more visually
| pleasing surfaces since non-selected inputs are not considered during
| smoothing. However, this also means that the generated surface will change
| shape depending on which inputs are selected.
|
| .. note::
|
| Selecting inputs can affect whether a boundary polygon is considered to
| be ``internal`` or ``external``. That is, an internal boundary becomes an
| external boundary when only one of the two foreground regions on the
| boundary is selected.
|
| select_outputs : int | VectorLike[int], default: None
| Specify label ids to include in the output of the filter. Labels that are
| not selected are removed from the output *after* generating the surface. By
| default, all label ids are used.
|
| Since the smoothing operation occurs across all input regions, using this
| option to filter the output means that the selected output regions will have
| the same shape (i.e. smoothed in the same manner), regardless of the outputs
| that are selected. This is useful for generating a surface for specific
| labels while also preserving sharp boundaries with non-selected outputs.
|
| .. note::
|
| Selecting outputs does not affect whether a boundary polygon is
| considered to be ``internal`` or ``external``. That is, an internal
| boundary remains internal even if only one of the two foreground regions
| on the boundary is selected.
|
| pad_background : bool, default: True
| :meth:`Pad <pyvista.ImageDataFilters.pad_image>` the image
| with ``background_value`` prior to contouring. This will
| generate polygons to "close" the surface at the boundaries of the image.
| This option is only relevant when there are foreground regions on the border
| of the image. Setting this value to ``False`` is useful if processing multiple
| volumes separately so that the generated surfaces fit together without
| creating surface overlap.
|
| output_mesh_type : str, default: None
| Type of the output mesh. Can be either ``'quads'``, or ``'triangles'``. By
| default, the output mesh has :attr:`~pyvista.CellType.TRIANGLE` cells when
| ``smoothing`` is enabled and :attr:`~pyvista.CellType.QUAD` cells (quads)
| otherwise. The mesh type can be forced to be triangles or quads; however,
| if smoothing is enabled and the type is ``'quads'``, the generated quads
| may not be planar.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars. If cell
| scalars are specified, the input image is first re-meshed with
| :meth:`~pyvista.ImageDataFilters.cells_to_points` to transform the cell
| data into point data.
|
| orient_faces : bool, optional
| .. deprecated:: 0.47
|
| This keyword should not be used and will be removed in a future version. It was
| meant to address a vtk bug where the faces generated by :vtk:`vtkSurfaceNets3D`
| have incorrect orientation. This bug is fixed in VTK 9.6, and therefore the faces
| now always have correct orientation by default.
|
| Orient the faces of the generated contours so that they have consistent
| ordering and face outward. If ``False``, the generated polygons may have
| inconsistent ordering and orientation, which can negatively impact
| downstream calculations and the shading used for rendering.
|
| .. note::
|
| Orienting the faces can be computationally expensive for large meshes.
| Consider disabling this option to improve this filter's performance.
|
| .. warning::
|
| Enabling this option is `likely` to generate surfaces with normals
| pointing outward when ``pad_background`` is ``True`` and
| ``boundary_style`` is ``'external'`` (the default). However, this is
| not guaranteed if the generated surface is not closed or if internal
| boundaries are generated. Do not assume the normals will point outward
| in all cases.
|
| simplify_output : bool, optional
| Simplify the ``'boundary_labels'`` array as a single-component 1D array.
| If ``False``, the returned ``'boundary_labels'`` array is a two-component
| 2D array. This simplification is useful when only external boundaries
| are generated and/or when visualizing internal boundaries. The
| simplification is as follows:
|
| - External boundaries are simplified by keeping the first component and
| removing the second. Since external polygons may only share a boundary
| with the background, the second component is always ``background_value``
| and therefore can be dropped without loss of information. The values
| of external boundaries always match the foreground values of the input.
|
| - Internal boundaries are simplified by assigning them unique negative
| values sequentially. E.g. the boundary label ``[1, 2]`` is replaced with
| ``-1``, ``[1, 3]`` is replaced with ``-2``, etc. The mapping to negative
| values is not fixed, and can change depending on the input.
|
| This simplification is particularly useful for unsigned integer labels
| (e.g. scalars with ``'uint8'`` dtype) since external boundaries
| will be positive and internal boundaries will be negative in this case.
|
| By default, the output is simplified when ``boundary_type`` is
| ``'external'`` or ``'strict_external'``, and is not simplified otherwise.
|
| smoothing : bool, default: True
| Smooth the generated surface using a constrained smoothing filter. Each
| point in the surface is smoothed as follows:
|
| For a point ``pi`` connected to a list of points ``pj`` via an edge, ``pi``
| is moved towards the average position of ``pj`` multiplied by the
| ``smoothing_relaxation`` factor, and limited by the ``smoothing_distance``
| constraint. This process is repeated either until convergence occurs, or
| the maximum number of ``smoothing_iterations`` is reached.
|
| smoothing_iterations : int, default: 16
| Maximum number of smoothing iterations to use.
|
| smoothing_relaxation : float, default: 0.5
| Relaxation factor used at each smoothing iteration.
|
| smoothing_distance : float, default: None
| Maximum distance each point is allowed to move (in any direction) during
| smoothing. This distance may be scaled with ``smoothing_scale``. By default,
| the distance is computed dynamically from the image spacing as:
|
| ``distance = norm(image_spacing) * smoothing_scale``.
|
| smoothing_scale : float, default: 1.0
| Relative scaling factor applied to ``smoothing_distance``. See that
| parameter for details.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of labeled regions.
|
| See Also
| --------
| :meth:`~pyvista.DataSetFilters.voxelize_binary_mask`
| Filter that generates binary labeled :class:`~pyvista.ImageData` from
| :class:`~pyvista.PolyData` surface contours. Can beloosely considered as
| an inverse of this filter.
|
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter which can used to process the multi-component
| scalars generated by this filter.
|
| :meth:`~pyvista.DataSetFilters.contour`
| Generalized contouring method which uses MarchingCubes or FlyingEdges.
|
| :meth:`~pyvista.DataSetFilters.pack_labels`
| Function used internally by SurfaceNets to generate contiguous label data.
|
| :meth:`~pyvista.DataSetFilters.color_labels`
| Color labeled data, e.g. labeled volumes or contours.
|
| :ref:`contouring_example`, :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| References
| ----------
| S. Frisken, SurfaceNets for Multi-Label Segmentations with Preservation of
| Sharp Boundaries, J. Computer Graphics Techniques, 2022. Available online:
| http://jcgt.org/published/0011/01/03/
|
| W. Schroeder, S. Tsalikis, M. Halle, S. Frisken. A High-Performance SurfaceNets
| Discrete Isocontouring Algorithm. arXiv:2401.14906. 2024. Available online:
| `http://arxiv.org/abs/2401.14906 <http://arxiv.org/abs/2401.14906>`__
|
| Examples
| --------
| Load labeled image data with a background region ``0`` and four foreground
| regions.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> label_ids = np.unique(image.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
| >>> image.dimensions
| (251, 251, 101)
|
| Crop the image to simplify the data.
|
| >>> image = image.extract_subset(voi=(75, 109, 75, 109, 85, 100))
| >>> image.dimensions
| (35, 35, 16)
|
| Plot the cropped image for context. Use :meth:`~pyvista.DataSetFilters.color_labels`
| to generate consistent coloring of the regions for all plots. Negative indexing
| is used for plotting internal boundaries.
|
| >>> def labels_plotter(mesh, zoom=None):
| ... colored_mesh = mesh.color_labels(negative_indexing=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored_mesh, show_edges=True)
| ... if zoom:
| ... pl.camera.zoom(zoom)
| ... return pl
| >>>
| >>> labels_plotter(image).show()
|
| Generate surface contours of the foreground regions and plot it. Note that
| the ``background_value`` is ``0`` by default.
|
| >>> contours = image.contour_labels()
| >>> labels_plotter(contours, zoom=1.5).show()
|
| By default, only external boundary polygons are generated and the returned
| ``'boundary_labels'`` array is a single-component array. The output values
| match the input label values.
|
| >>> contours['boundary_labels'].ndim
| 1
| >>> np.unique(contours['boundary_labels'])
| pyvista_ndarray([1, 2, 3, 4])
|
| Set ``simplify_output`` to ``False`` to generate a two-component
| array instead showing the two boundary regions associated with each polygon.
|
| >>> contours = image.contour_labels(simplify_output=False)
| >>> contours['boundary_labels'].ndim
| 2
|
| Show the unique values. Since only ``'external'`` boundaries are generated
| by default, the second component is always ``0`` (i.e. the ``background_value``).
| Note that all four foreground regions share a boundary with the background.
|
| >>> np.unique(contours['boundary_labels'], axis=0)
| array([[1, 0],
| [2, 0],
| [3, 0],
| [4, 0]])
|
| Repeat the example but this time generate internal contours only. The generated
| array is 2D by default.
|
| >>> contours = image.contour_labels('internal')
| >>> contours['boundary_labels'].ndim
| 2
|
| Show the unique two-component boundary labels again. From these values we can
| determine that all foreground regions share an internal boundary with each
| other `except` for regions ``1`` and ``3`` since the boundary value ``[1, 3]``
| is missing.
|
| >>> np.unique(contours['boundary_labels'], axis=0)
| array([[1, 2],
| [1, 4],
| [2, 3],
| [2, 4],
| [3, 4]])
|
| Simplify the output so that each internal multi-component boundary value is
| assigned a unique negative integer value instead. This makes it easier to
| visualize the result with :meth:`~pyvista.DataSetFilters.color_labels` using
| the ``negative_indexing`` option.
|
| >>> contours = image.contour_labels('internal', simplify_output=True)
| >>> contours['boundary_labels'].ndim
| 1
| >>> np.unique(contours['boundary_labels'])
| pyvista_ndarray([-5, -4, -3, -2, -1])
|
| >>> labels_plotter(contours, zoom=1.5).show()
|
| Generate contours for all boundaries, and use ``select_outputs`` to filter
| the output to only include polygons which share a boundary with region ``3``.
|
| >>> region_3 = image.contour_labels(
| ... 'all', select_outputs=3, simplify_output=True
| ... )
| >>> labels_plotter(region_3, zoom=3).show()
|
| Note how using ``select_outputs`` preserves the sharp features and boundary
| labels for non-selected regions. If desired, use ``select_inputs`` instead to
| completely "ignore" non-selected regions.
|
| >>> region_3 = image.contour_labels(select_inputs=3)
| >>> labels_plotter(region_3, zoom=3).show()
|
| The sharp features are now smoothed and the internal boundaries are now labeled
| as external boundaries. Note that using ``'all'`` here is optional since
| using ``select_inputs`` converts previously-internal boundaries into external
| ones.
|
| Do not pad the image with background values before contouring. Since the input image
| has foreground regions visible at the edges of the image (e.g. the ``+Z`` bound),
| setting ``pad_background=False`` in this example causes the top and sides of
| the mesh to be "open".
|
| >>> surf = image.contour_labels(pad_background=False)
| >>> labels_plotter(surf, zoom=1.5).show()
|
| Disable smoothing to generate staircase-like surface. Without smoothing, the
| surface has quadrilateral cells by default.
|
| >>> surf = image.contour_labels(smoothing=False)
| >>> labels_plotter(surf, zoom=1.5).show()
|
| Keep smoothing enabled but reduce the smoothing scale. A smoothing scale
| less than one may help preserve sharp features (e.g. corners).
|
| >>> surf = image.contour_labels(smoothing_scale=0.5)
| >>> labels_plotter(surf, zoom=1.5).show()
|
| Use the ``'strict_external'`` style to compute external contours quickly. Note
| that this produces jagged and non-smooth boundaries between regions, which may
| not be desirable. Also note how the top of the surface is perfectly flat compared
| to the default ``'external'`` style (see first example above) since the strict
| style ignores the smoothing effects of all internal boundaries.
|
| >>> surf = image.contour_labels('strict_external')
| >>> labels_plotter(surf, zoom=1.5).show()
|
| crop(self: 'ImageData', *, factor: 'float | VectorLike[float] | None' = None, margin: 'int | VectorLike[int] | None' = None, offset: 'VectorLike[int] | None' = None, dimensions: 'VectorLike[int] | None' = None, extent: 'VectorLike[int] | None' = None, normalized_bounds: 'VectorLike[float] | None' = None, mask: 'str | ImageData | NumpyArray[float] | Literal[True] | None' = None, padding: 'int | VectorLike[int] | None' = None, background_value: 'float | None' = None, keep_dimensions: 'bool' = False, fill_value: 'float | VectorLike[float] | None' = None, rebase_coordinates: 'bool' = False, progress_bar: 'bool' = False) -> 'ImageData'
| Crop this image to remove points at its boundaries.
|
| This filter is useful for extracting a volume or region of interest. There are several ways
| to crop:
|
| #. Use ``factor`` to crop a portion of the image symmetrically.
| #. Use ``margin`` to remove points from the image border.
| #. Use ``dimensions`` (and optionally, ``offset``) to explicitly crop to the specified
| :attr:`~pyvista.ImageData.dimensions` and :attr:`~pyvista.ImageData.offset`.
| #. Use ``extent`` to explicitly crop to a specified :attr:`~pyvista.ImageData.extent`.
| #. Use ``normalized_bounds`` to crop a bounding box relative to the input size.
| #. Use ``mask``, ``padding``, and ``background_value`` to crop to this mesh using scalar
| values to define the cropping region.
|
| These methods are all independent, e.g. it is not possible to specify both ``factor`` and
| ``margin``.
|
| By default, the cropped output's :attr:`~pyvista.ImageData.dimensions` are typically less
| than the input's dimensions. Optionally, use ``keep_dimensions`` and ``fill_value`` to
| ensure the output dimensions always match the input.
|
| .. note::
|
| All cropping is performed using the image's ijk-indices, not physical xyz-bounds.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| factor : float, optional
| Cropping factor in range ``[0.0, 1.0]`` which specifies the proportion of the image to
| keep along each axis. Use a single float for uniform cropping or a vector of three
| floats for cropping each xyz-axis independently. The crop is centered in the image.
|
| margin : int | VectorLike[int], optional
| Margin to remove from each side of each axis. Specify:
|
| - A single value to remove from all boundaries equally.
| - Two values, one for each ``(X, Y)`` axis, to remove margin from
| each axis independently.
| - Three values, one for each ``(X, Y, Z)`` axis, to remove margin from
| each axis independently.
| - Four values, one for each ``(-X, +X, -Y, +Y)`` boundary, to remove
| margin from each boundary independently.
| - Six values, one for each ``(-X, +X, -Y, +Y, -Z, +Z)`` boundary, to remove
| margin from each boundary independently.
|
| offset : VectorLike[int], optional
| Length-3 vector of integers specifying the :attr:`~pyvista.ImageData.offset` indices
| where the cropping region originates. If specified, then ``dimensions`` must also be
| provided.
|
| dimensions : VectorLike[int], optional
| Length-3 vector of integers specifying the :attr:`~pyvista.ImageData.dimensions` of
| the cropping region. ``offset`` may also be provided, but if it is not, the crop is
| centered in the image.
|
| extent : VectorLike[int], optional
| Length-6 vector of integers specifying the full :attr:`~pyvista.ImageData.extent` of
| the cropping region.
|
| normalized_bounds : VectorLike[float], optional
| Normalized bounds relative to the input. These are floats between ``0.0`` and ``1.0``
| that define a box relative to the input size. The input is cropped such that it fully
| fits within these bounds. Has the form ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| mask : str | ImageData | NumpyArray[float] | bool, optional
| Scalar values that define the cropping region. Set this option to:
|
| - a string denoting the name of scalars belonging to this mesh
| - ``True`` to use this mesh's default scalars
| - a separate image, in which case the other image's active scalars are used
| - a 1D or 2D (multi-component) array
|
| The length of the scalar array must equal the number of points.
|
| This mesh will be cropped to the bounds of the foreground values of the array, i.e.
| values that are not equal to the specified ``background_value``.
|
| padding : int | VectorLike[int], optional
| Padding to add to foreground region `before` cropping. Only valid when using a mask to
| crop the image. Specify:
|
| - A single value to pad all boundaries equally.
| - Two values, one for each ``(X, Y)`` axis, to apply symmetric padding to
| each axis independently.
| - Three values, one for each ``(X, Y, Z)`` axis, to apply symmetric padding
| to each axis independently.
| - Four values, one for each ``(-X, +X, -Y, +Y)`` boundary, to apply
| padding to each boundary independently.
| - Six values, one for each ``(-X, +X, -Y, +Y, -Z, +Z)`` boundary, to apply
| padding to each boundary independently.
|
| The specified value is the `maximum` padding that may be applied. If the padding
| extends beyond the actual extents of this mesh, it is clipped and does not extend
| outside the bounds of the image.
|
| background_value : float | VectorLike[float], optional
| Value or multi-component vector considered to be the background. Only valid when using
| a mask to crop the image.
|
| keep_dimensions : bool, default: False
| If ``True``, the cropped output is :meth:`padded <pad_image>` with ``fill_value`` to
| ensure the output dimensions match the input.
|
| fill_value : float | VectorLike[float], optional
| Value used when padding the cropped output if ``keep_dimensions`` is ``True``. May be
| a single float or a multi-component vector (e.g. RGB vector).
|
| rebase_coordinates : bool, default: False
| Rebase the coordinate reference of the cropped output:
|
| - the :attr:`~pyvista.ImageData.origin` is set to the minimum bounds of the subset
| - the :attr:`~pyvista.ImageData.offset` is reset to ``(0, 0, 0)``
|
| The rebasing effectively applies a positive translation in world (XYZ) coordinates and
| a similar (i.e. inverse) negative translation in voxel (IJK) coordinates. As a result,
| the :attr:`~pyvista.DataSet.bounds` of the output are unchanged, but the coordinate
| reference frame is modified.
|
| Set this to ``False`` to leave the origin unmodified and keep the offset used by the
| crop.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Cropped image.
|
| See Also
| --------
| pad_image
| Add points to image boundaries. This is the inverse operation of the ``margin`` crop.
|
| resample
| Modify an image's dimensions and spacing.
|
| select_values
| Threshold-like filter which may be used to generate a mask for cropping.
|
| extract_subset
| Equivalent filter to ``crop(extent=voi, rebase_coordinates=True)``.
|
| :ref:`crop_labeled_example`
| Example cropping :class:`~pyvista.ImageData` using a segmentation mask.
|
| Examples
| --------
| Load a grayscale image.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> gray_image = examples.download_yinyang()
| >>> gray_image.dimensions
| (512, 342, 1)
|
| Define a custom plotting helper to show the image as pixel cells.
|
| >>> def image_plotter(image):
| ... pixel_cells = image.points_to_cells()
| ...
| ... pl = pv.Plotter()
| ... pl.add_mesh(
| ... pixel_cells,
| ... cmap='gray',
| ... clim=[0, 255],
| ... lighting=False,
| ... show_scalar_bar=False,
| ... )
| ... pl.view_xy()
| ... pl.camera.tight()
| ... return pl
|
| Plot the image for context.
|
| >>> image_plotter(gray_image).show()
|
| Crop the white border around the image using active scalars as a mask. Here we specify a
| background value of ``255`` to correspond to white pixels. If this was an RGB image, we
| could also specify ``(255, 255, 255)`` as the background value.
|
| >>> cropped = gray_image.crop(mask=True, background_value=255)
| >>> cropped.dimensions
| (237, 238, 1)
| >>> image_plotter(cropped).show()
|
| Use ``margin`` instead to remove 100 and 20 pixels from each side of the x- and y-axis,
| respectively.
|
| >>> cropped = gray_image.crop(margin=(100, 20))
| >>> cropped.dimensions
| (312, 302, 1)
| >>> image_plotter(cropped).show()
|
| Use ``offset`` to select a starting location for the crop (from the origin at the
| bottom-left corner) along with ``dimensions`` to define the crop size.
|
| >>> cropped = gray_image.crop(offset=(50, 20, 0), dimensions=(300, 200, 1))
| >>> cropped.dimensions
| (300, 200, 1)
| >>> image_plotter(cropped).show()
|
| Use ``extent`` directly instead of using ``dimensions`` and ``offset`` to yield the same
| result as above.
|
| >>> cropped = gray_image.crop(extent=(50, 349, 20, 219, 0, 0))
| >>> cropped.extent
| (50, 349, 20, 219, 0, 0)
| >>> image_plotter(cropped).show()
|
| Use ``factor`` to crop 40% of the image. This `keeps` 40% of the pixels along each axis,
| and `removes` 60% (i.e. 30% from each side).
|
| >>> cropped = gray_image.crop(factor=0.4)
| >>> cropped.dimensions
| (204, 136, 1)
| >>> image_plotter(cropped).show()
|
| Use ``normalized_bounds`` to crop from 40% to 80% of the image along the x-axis, and
| from 30% to 90% of the image along the y-axis.
|
| >>> cropped = gray_image.crop(normalized_bounds=[0.4, 0.8, 0.3, 0.9, 0.0, 1.0])
| >>> cropped.extent
| (205, 408, 103, 306, 0, 0)
| >>> image_plotter(cropped).show()
|
| dilate(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Morphologically dilate grayscale or binary data.
|
| This filter may be used to dilate grayscale images with continuous data, binary images
| with a single background and foreground value, or multi-label images.
|
| For binary inputs with two unique values, this filter uses :vtk:`vtkImageDilateErode3D`
| by default to perform fast binary dilation over an ellipsoidal neighborhood. Otherwise,
| the slower class :vtk:`vtkImageContinuousDilate3D` is used to perform generalized grayscale
| dilation by replacing each pixel with the maximum over an ellipsoidal neighborhood.
|
| Optionally, the ``binary`` keyword may be used to explicitly control the behavior of the
| filter.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are dilated, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary dilation or continuous dilation is used.
|
| If set, :vtk:`vtkImageDilateErode3D` is used to strictly dilate with two values.
| Set this to ``True`` to dilate the maximum value in ``scalars`` with its minimum value,
| or set it to two values ``[background_value, foreground_value]`` to dilate
| ``foreground_value`` with ``background_value`` explicitly.
|
| Set this to ``False`` to use :vtk:`vtkImageContinuousDilate3D` to perform continuous
| dilation.
|
| By default, ``binary`` is ``True`` if the input has two unique values, and ``False``
| otherwise.
|
| .. note::
| - If the input is a binary mask, setting ``binary=True`` produces the same output
| as ``binary=False``, but the filter is much more performant.
| - Setting ``binary=[background_value, foreground_value]`` is useful to `isolate`
| the dilation to two values, e.g. for multi-label segmentation masks.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been dilated.
|
| See Also
| --------
| erode, open, close
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| .. pyvista-plot::
| :force_static:
|
| Create a toy example with two non-zero grayscale foreground values
| :meth:`padded <pad_image>` with a background of zeros.
|
| >>> import pyvista as pv
| >>> im = pv.ImageData(dimensions=(2, 1, 1))
| >>> im['data'] = [128, 255]
| >>> im = im.pad_image(pad_value=0, pad_size=2, dimensionality=2)
|
| Define a custom plotter to plot pixels as cells.
|
| >>> def image_plotter(image):
| ... pl = pv.Plotter()
| ... pl.add_mesh(
| ... image.points_to_cells(),
| ... cmap='grey',
| ... clim=[0, 255],
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... lighting=False,
| ... line_width=3,
| ... )
| ... pl.camera_position = 'xy'
| ... pl.camera.tight()
| ... pl.enable_anti_aliasing()
| ... return pl
|
| Show the image.
|
| >>> image_plotter(im).show()
|
| Dilate it with default settings. Observe that `both` foreground values are dilated.
|
| >>> dilated = im.dilate()
| >>> image_plotter(dilated).show()
|
| Use a larger kernel size.
|
| >>> dilated = im.dilate(kernel_size=5)
| >>> image_plotter(dilated).show()
|
| Use an asymmetric kernel.
|
| >>> dilated = im.dilate(kernel_size=(2, 4, 1))
| >>> image_plotter(dilated).show()
|
| Use binary dilation. By default, the max value (``255`` in this example) is dilated
| with the min value (``0`` in this example). All other values are unaffected.
|
| >>> dilated = im.dilate(binary=True)
| >>> image_plotter(dilated).show()
|
| Equivalently, set the binary values for the dilation explicitly.
|
| >>> dilated = im.dilate(binary=[0, 255])
| >>> image_plotter(dilated).show()
|
| Use binary dilation with the other foreground value instead.
|
| >>> dilated = im.dilate(binary=[0, 128])
| >>> image_plotter(dilated).show()
|
| erode(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Morphologically erode grayscale or binary data.
|
| This filter may be used to erode grayscale images with continuous data, binary images
| with a single background and foreground value, or multi-label images.
|
| For binary inputs with two unique values, this filter uses :vtk:`vtkImageDilateErode3D`
| by default to perform fast binary erosion over an ellipsoidal neighborhood. Otherwise,
| the slower class :vtk:`vtkImageContinuousErode3D` is used to perform generalized grayscale
| erosion by replacing each pixel with the minimum over an ellipsoidal neighborhood.
|
| Optionally, the ``binary`` keyword may be used to explicitly control the behavior of the
| filter.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are eroded, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary erosion or continuous erosion is used.
|
| If set, :vtk:`vtkImageDilateErode3D` is used to strictly erode with two values.
| Set this to ``True`` to erode the maximum value in ``scalars`` with its minimum value,
| or set it to two values ``[background_value, foreground_value]`` to erode
| ``foreground_value`` with ``background_value`` explicitly.
|
| Set this to ``False`` to use :vtk:`vtkImageContinuousErode3D` to perform continuous
| erosion.
|
| By default, ``binary`` is ``True`` if the input has two unique values, and ``False``
| otherwise.
|
| .. note::
| - If the input is a binary mask, setting ``binary=True`` produces the same output
| as ``binary=False``, but the filter is much more performant.
| - Setting ``binary=[background_value, foreground_value]`` is useful to `isolate`
| the erosion to two values, e.g. for multi-label segmentation masks.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been eroded.
|
| See Also
| --------
| dilate, open, close
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| .. pyvista-plot::
| :force_static:
|
| Create a toy example with two non-zero grayscale foreground regions
| using :meth:`pad_image`.
|
| >>> import pyvista as pv
| >>> # Create an initial background point
| >>> im = pv.ImageData(dimensions=(1, 1, 1))
| >>> im['data'] = [0]
| >>> # Add a foreground region
| >>> im = im.pad_image(pad_value=255, pad_size=(4, 3), dimensionality=2)
| >>> # Add a second foreground region
| >>> im = im.pad_image(pad_value=128, pad_size=(2, 0, 1, 0))
| >>> # Add background values to two sides
| >>> im = im.pad_image(pad_value=0, pad_size=(1, 0))
|
| Define a custom plotter to plot pixels as cells.
|
| >>> def image_plotter(image):
| ... pl = pv.Plotter()
| ... pl.add_mesh(
| ... image.points_to_cells(),
| ... cmap='grey',
| ... clim=[0, 255],
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... lighting=False,
| ... line_width=3,
| ... )
| ... pl.camera_position = 'xy'
| ... pl.camera.tight()
| ... pl.enable_anti_aliasing()
| ... return pl
|
| Show the image.
|
| >>> image_plotter(im).show()
|
| Erode it with default settings. Observe that `both` foreground values are eroded.
|
| >>> eroded = im.erode()
| >>> image_plotter(eroded).show()
|
| Use a larger kernel size.
|
| >>> eroded = im.erode(kernel_size=5)
| >>> image_plotter(eroded).show()
|
| Use an asymmetric kernel.
|
| >>> eroded = im.erode(kernel_size=(2, 4, 1))
| >>> image_plotter(eroded).show()
|
| Use binary erosion. By default, the max value (``255`` in this example) is eroded
| with the min value (``0`` in this example). All other values are unaffected.
|
| >>> eroded = im.erode(binary=True)
| >>> image_plotter(eroded).show()
|
| Equivalently, set the binary values for the erosion explicitly.
|
| >>> eroded = im.erode(binary=[0, 255])
| >>> image_plotter(eroded).show()
|
| Use binary erosion with the other foreground value instead.
|
| >>> eroded = im.erode(binary=[0, 128])
| >>> image_plotter(eroded).show()
|
| extract_subset(self, voi, rate=(1, 1, 1), boundary: 'bool' = False, rebase_coordinates: 'bool' = True, progress_bar: 'bool' = False)
| Select piece (e.g., volume of interest).
|
| To use this filter set the VOI ivar which are i-j-k min/max indices
| that specify a rectangular region in the data. (Note that these are
| 0-offset.) You can also specify a sampling rate to subsample the
| data.
|
| Typical applications of this filter are to extract a slice from a
| volume for image processing, subsampling large volumes to reduce data
| size, or extracting regions of a volume with interesting data.
|
| Parameters
| ----------
| voi : sequence[int]
| Length 6 iterable of ints: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| These bounds specify the volume of interest in i-j-k min/max
| indices.
|
| rate : sequence[int], default: (1, 1, 1)
| Length 3 iterable of ints: ``(xrate, yrate, zrate)``.
|
| boundary : bool, default: False
| Control whether to enforce that the "boundary" of the grid
| is output in the subsampling process. This only has effect
| when the rate in any direction is not equal to 1. When
| this is enabled, the subsampling will always include the
| boundary of the grid even though the sample rate is not an
| even multiple of the grid dimensions. By default this is
| disabled.
|
| rebase_coordinates : bool, default: True
| If ``True`` (default), reset the coordinate reference of the extracted subset:
|
| - the :attr:`~pyvista.ImageData.origin` is set to the minimum bounds of the subset
| - the :attr:`~pyvista.ImageData.offset` is reset to ``(0, 0, 0)``
|
| The rebasing effectively applies a positive translation in world (XYZ) coordinates and
| a similar (i.e. inverse) negative translation in voxel (IJK) coordinates. As a result,
| the :attr:`~pyvista.DataSet.bounds` of the output are unchanged, but the coordinate
| reference frame is modified.
|
| Set this to ``False`` to leave the origin unmodified and keep the offset specified by
| the ``voi`` parameter.
|
| .. versionadded:: 0.46
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| ImageData subset.
|
| See Also
| --------
| slice_index
| crop
|
| fft(self, output_scalars_name=None, progress_bar: 'bool' = False)
| Apply a fast Fourier transform (FFT) to the active scalars.
|
| The input can be real or complex data, but the output is always
| :attr:`numpy.complex128`. The filter is fastest for images that have
| power of two sizes.
|
| The filter uses a butterfly diagram for each prime factor of the
| dimension. This makes images with prime number dimensions (i.e. 17x17)
| much slower to compute. FFTs of multidimensional meshes (i.e volumes)
| are decomposed so that each axis executes serially.
|
| The frequencies of the output assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with applied FFT.
|
| See Also
| --------
| rfft : The reverse transform.
| low_pass : Low-pass filtering of FFT output.
| high_pass : High-pass filtering of FFT output.
|
| Examples
| --------
| Apply FFT to an example image.
|
| >>> from pyvista import examples
| >>> image = examples.download_moonlanding_image()
| >>> fft_image = image.fft()
| >>> fft_image.point_data # doctest:+SKIP
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : PNGImage
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| PNGImage complex128 (298620,) SCALARS
|
| See :ref:`image_fft_example` for a full example using this filter.
|
| gaussian_smooth(self, radius_factor=1.5, std_dev=2.0, scalars=None, progress_bar: 'bool' = False)
| Smooth the data with a Gaussian kernel.
|
| Parameters
| ----------
| radius_factor : float | sequence[float], default: 1.5
| Unitless factor to limit the extent of the kernel.
|
| std_dev : float | sequence[float], default: 2.0
| Standard deviation of the kernel in pixel units.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Uniform grid with smoothed scalars.
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| First, create sample data to smooth. Here, we use
| :func:`pyvista.perlin_noise() <pyvista.core.utilities.features.perlin_noise>`
| to create meaningful data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 5, 8), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1, 0, 1, 0, 1], dim=(20, 20, 20)
| ... )
| >>> grid.plot(show_scalar_bar=False)
|
| Next, smooth the sample data.
|
| >>> smoothed = grid.gaussian_smooth()
| >>> smoothed.plot(show_scalar_bar=False)
|
| See :ref:`gaussian_smoothing_example` for a full example using this filter.
|
| high_pass(self, x_cutoff, y_cutoff, z_cutoff, order=1, output_scalars_name=None, progress_bar: 'bool' = False)
| Perform a Butterworth high pass filter in the frequency domain.
|
| This filter requires that the :class:`ImageData` have a complex point
| scalars, usually generated after the :class:`ImageData` has been
| converted to the frequency domain by a :func:`ImageDataFilters.fft`
| filter.
|
| A :func:`ImageDataFilters.rfft` filter can be used to convert the
| output back into the spatial domain. This filter attenuates low
| frequency components. Input and output are complex arrays with
| datatype :attr:`numpy.complex128`.
|
| The frequencies of the input assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| x_cutoff : float
| The cutoff frequency for the x-axis.
|
| y_cutoff : float
| The cutoff frequency for the y-axis.
|
| z_cutoff : float
| The cutoff frequency for the z-axis.
|
| order : int, default: 1
| The order of the cutoff curve. Given from the equation
| ``1/(1 + (cutoff/freq(i, j))**(2*order))``.
|
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with the applied high pass filter.
|
| See Also
| --------
| fft : Direct fast Fourier transform.
| rfft : Reverse fast Fourier transform.
| low_pass : Low-pass filtering of FFT output.
|
| Examples
| --------
| See :ref:`image_fft_perlin_noise_example` for a full example using this filter.
|
| image_dilate_erode(self, dilate_value=1.0, erode_value=0.0, kernel_size=(3, 3, 3), scalars=None, progress_bar: 'bool' = False)
| Dilates one value and erodes another.
|
| .. deprecated:: 0.47.0
| :meth:`image_dilate_erode` is deprecated. Use :meth:`dilate`, :meth:`erode`,
| :meth:`open`, or :meth:`close` instead.
|
| ``image_dilate_erode`` will dilate one value and erode another. It uses
| an elliptical footprint, and only erodes/dilates on the boundary of the
| two values. The filter is restricted to the X, Y, and Z axes for now.
| It can degenerate to a 2 or 1-dimensional filter by setting the kernel
| size to 1 for a specific axis.
|
| Parameters
| ----------
| dilate_value : float, default: 1.0
| Dilate value in the dataset.
|
| erode_value : float, default: 0.0
| Erode value in the dataset.
|
| kernel_size : sequence[int], default: (3, 3, 3)
| Determines the size of the kernel along the three axes.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been dilated/eroded on the boundary of the specified scalars.
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| Demonstrate image dilate/erode on an example dataset. First, plot
| the example dataset with the active scalars.
|
| >>> from pyvista import examples
| >>> uni = examples.load_uniform()
| >>> uni.plot()
|
| Now, plot the image threshold with ``threshold=[400, 600]``. Note how
| values within the threshold are 1 and outside are 0.
|
| >>> ithresh = uni.image_threshold([400, 600])
| >>> ithresh.plot()
|
| Note how there is a hole in the thresholded image. Apply a closing
| filter with a large kernel to fill that hole in.
|
| >>> iclosed = ithresh.close(kernel_size=[5, 5, 5])
| >>> iclosed.plot()
|
| image_threshold(self: 'ImageData', threshold, in_value=1.0, out_value=0.0, scalars=None, preference='point', progress_bar: 'bool' = False)
| Apply a threshold to scalar values in a uniform grid.
|
| If a single value is given for threshold, scalar values above or equal
| to the threshold are ``'in'`` and scalar values below the threshold are ``'out'``.
| If two values are given for threshold (sequence) then values equal to
| or between the two values are ``'in'`` and values outside the range are ``'out'``.
|
| If ``None`` is given for ``in_value``, scalars that are ``'in'`` will not be replaced.
| If ``None`` is given for ``out_value``, scalars that are ``'out'`` will not be replaced.
|
| Warning: applying this filter to cell data will send the output to a
| new point array with the same name, overwriting any existing point data
| array with the same name.
|
| Parameters
| ----------
| threshold : float or sequence[float]
| Single value or (min, max) to be used for the data threshold. If
| a sequence, then length must be 2. Threshold(s) for deciding which
| cells/points are ``'in'`` or ``'out'`` based on scalar data.
|
| in_value : float, default: 1.0
| Scalars that match the threshold criteria for ``'in'`` will be replaced with this.
|
| out_value : float, default: 0.0
| Scalars that match the threshold criteria for ``'out'`` will be replaced with this.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset with the specified scalars thresholded.
|
| See Also
| --------
| select_values
| Threshold-like method for keeping some values and replacing others.
| :meth:`~pyvista.DataSetFilters.threshold`
| General threshold method that returns a :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Demonstrate image threshold on an example dataset. First, plot
| the example dataset with the active scalars.
|
| >>> from pyvista import examples
| >>> uni = examples.load_uniform()
| >>> uni.plot()
|
| Now, plot the image threshold with ``threshold=100``. Note how
| values above the threshold are 1 and below are 0.
|
| >>> ithresh = uni.image_threshold(100)
| >>> ithresh.plot()
|
| See :ref:`image_representations_example` for more examples using this filter.
|
| label_connectivity(self, *, scalars: 'str | None' = None, scalar_range: "Literal['auto', 'foreground', 'vtk_default'] | VectorLike[float]" = 'auto', extraction_mode: "Literal['all', 'largest', 'seeded']" = 'all', point_seeds: 'MatrixLike[float] | VectorLike[float] | _vtk.vtkDataSet | None' = None, label_mode: "Literal['size', 'constant', 'seeds']" = 'size', constant_value: 'int | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False) -> 'tuple[ImageData, NDArray[int], NDArray[int]]'
| Find and label connected regions in a :class:`~pyvista.ImageData`.
|
| Only points whose `scalar` value is within the `scalar_range` are considered for
| connectivity. A 4-connectivity is used for 2D images or a 6-connectivity for 3D
| images. This filter operates on point-based data. If cell-based data are provided,
| they are re-meshed to a point-based representation using
| :func:`~pyvista.ImageDataFilters.cells_to_points` and the output is meshed back
| to a cell-based representation with :func:`~pyvista.ImageDataFilters.points_to_cells`,
| effectively filtering based on face connectivity. The connected regions are
| extracted and labelled according to the strategy defined by ``extraction_mode``
| and ``label_mode``, respectively. Unconnected regions are labelled with ``0`` value.
|
| .. versionadded:: 0.45.0
|
| Notes
| -----
| This filter implements :vtk:`vtkImageConnectivityFilter`.
|
| Parameters
| ----------
| scalars : str, optional
| Scalars to use to filter points. If ``None`` is provided, the scalars is
| automatically set, if possible.
|
| scalar_range : str, Literal['auto', 'foreground', 'vtk_default'], VectorLike[float]
| Points whose scalars value is within ``'scalar_range'`` are considered for
| connectivity. The bounds are inclusive.
|
| - ``'auto'``: (default) includes the full data range, similarly to
| :meth:`~pyvista.DataSetFilters.connectivity`.
| - ``'foreground'``: includes the full data range except the smallest value.
| - ``'vtk_default'``: default to [``0.5``, :const:`~vtk.VTK_DOUBLE_MAX`].
| - ``VectorLike[float]``: explicitly set the range.
|
| The bounds are always cast to floats since vtk expects doubles. The scalars
| data are also cast to floats to avoid unexpected behavior arising from implicit
| type conversion. The only exceptions is if both bounds are whole numbers, in
| which case the implicit conversion is safe. It will optimize resources consumption
| if the data are integers.
|
| extraction_mode : Literal['all', 'largest', 'seeded'], default: 'all'
| Determine how the connected regions are extracted. If ``'all'``, all connected
| regions are extracted. If ``'largest'``, only the largest region is extracted.
| If ``'seeded'``, only the regions that include the points defined with
| ``point_seeds`` are extracted.
|
| point_seeds : MatrixLike[float], VectorLike[float], :vtk:`vtkDataSet`, optional
| The point coordinates to use as seeds, specified as a (N, 3) array like or
| as a :vtk:`vtkDataSet`. Has no effect if ``extraction_mode`` is not
| ``'seeded'``.
|
| label_mode : Literal['size', 'constant', 'seeds'], default: 'size'
| Determine how the extracted regions are labelled. If ``'size'``, label regions
| by decreasing size (i.e., count of cells), starting at ``1``. If ``'constant'``,
| label with the provided ``constant_value``. If ``'seeds'``, label according to
| the seed order, starting at ``1``.
|
| constant_value : int, optional
| The constant label value to use. Has no effect if ``label_mode`` is not ``'seeds'``.
|
| inplace : bool, default: False
| If ``True``, perform an inplace labelling of the ImageData. Else, returns a
| new ImageData.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Either the input ImageData or a generated one where connected regions are
| labelled with a ``'RegionId'`` point-based or cell-based data.
|
| NDArray[int]
| The labels of each extracted regions.
|
| NDArray[int]
| The size (i.e., number of cells) of each extracted regions.
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Similar general-purpose filter that performs 1-connectivity.
|
| Examples
| --------
| Prepare a segmented grid.
|
| >>> import pyvista as pv
| >>> segmented_grid = pv.ImageData(dimensions=(4, 3, 3))
| >>> segmented_grid.cell_data['Data'] = [
| ... 0,
| ... 0,
| ... 0,
| ... 1,
| ... 0,
| ... 1,
| ... 1,
| ... 2,
| ... 0,
| ... 0,
| ... 0,
| ... 0,
| ... ]
| >>> segmented_grid.plot(show_edges=True)
|
| Label the connected regions. The cells with a ``0`` value are excluded from the
| connected regions and labelled with ``0``. The remaining cells define 3 different
| regions that are labelled by decreasing size.
|
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range='foreground'
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| Exclude the cell with a ``2`` value.
|
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range=[1, 1]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| Label all connected regions with a constant value.
|
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range='foreground',
| ... label_mode='constant',
| ... constant_value=10,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| Label only the regions that include seed points, by seed order.
|
| >>> points = [(2.0, 1.0, 0.0), (0.0, 0.0, 1.0)]
| >>> connected, labels, sizes = segmented_grid.label_connectivity(
| ... scalar_range='foreground',
| ... extraction_mode='seeded',
| ... point_seeds=points,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(connected.threshold(0.5), show_edges=True)
| >>> _ = pl.add_mesh(
| ... connected.threshold(0.5, invert=True),
| ... show_edges=True,
| ... opacity=0.5,
| ... )
| >>> pl.show()
|
| low_pass(self, x_cutoff, y_cutoff, z_cutoff, order=1, output_scalars_name=None, progress_bar: 'bool' = False)
| Perform a Butterworth low pass filter in the frequency domain.
|
| This filter requires that the :class:`ImageData` have a complex point
| scalars, usually generated after the :class:`ImageData` has been
| converted to the frequency domain by a :func:`ImageDataFilters.fft`
| filter.
|
| A :func:`ImageDataFilters.rfft` filter can be used to convert the
| output back into the spatial domain. This filter attenuates high
| frequency components. Input and output are complex arrays with
| datatype :attr:`numpy.complex128`.
|
| The frequencies of the input assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| x_cutoff : float
| The cutoff frequency for the x-axis.
|
| y_cutoff : float
| The cutoff frequency for the y-axis.
|
| z_cutoff : float
| The cutoff frequency for the z-axis.
|
| order : int, default: 1
| The order of the cutoff curve. Given from the equation
| ``1 + (cutoff/freq(i, j))**(2*order)``.
|
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with the applied low pass filter.
|
| See Also
| --------
| fft : Direct fast Fourier transform.
| rfft : Reverse fast Fourier transform.
| high_pass : High-pass filtering of FFT output.
|
| Examples
| --------
| See :ref:`image_fft_perlin_noise_example` for a full example using this filter.
|
| median_smooth(self, kernel_size=(3, 3, 3), scalars=None, preference='point', progress_bar: 'bool' = False)
| Smooth data using a median filter.
|
| The Median filter that replaces each pixel with the median value from a
| rectangular neighborhood around that pixel. Neighborhoods can be no
| more than 3 dimensional. Setting one axis of the neighborhood
| kernelSize to 1 changes the filter into a 2D median.
|
| See :vtk:`vtkImageMedian3D` for more details.
|
| Parameters
| ----------
| kernel_size : sequence[int], default: (3, 3, 3)
| Size of the kernel in each dimension (units of voxels), for example
| ``(x_size, y_size, z_size)``. Default is a 3D median filter. If you
| want to do a 2D median filter, set the size to 1 in the dimension
| you don't want to filter over.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Uniform grid with smoothed scalars.
|
| Warnings
| --------
| Applying this filter to cell data will send the output to a new point
| array with the same name, overwriting any existing point data array
| with the same name.
|
| Examples
| --------
| First, create sample data to smooth. Here, we use
| :func:`pyvista.perlin_noise() <pyvista.core.utilities.features.perlin_noise>`
| to create meaningful data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 5, 8), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1, 0, 1, 0, 1], dim=(20, 20, 20)
| ... )
| >>> grid.plot(show_scalar_bar=False)
|
| Next, smooth the sample data.
|
| >>> smoothed = grid.median_smooth(kernel_size=(10, 10, 10))
| >>> smoothed.plot(show_scalar_bar=False)
|
| open(self: 'ImageData', kernel_size: 'int | VectorLike[int]' = (3, 3, 3), scalars: 'str | None' = None, *, binary: 'bool | VectorLike[float] | None' = None, progress_bar: 'bool' = False)
| Perform morphological opening on continuous or binary data.
|
| Opening is an :meth:`erosion <erode>` followed by a :meth:`dilation <dilate>`.
| It is used to remove small objects/noise while preserving the shape and size of larger
| objects.
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| kernel_size : int | VectorLike[int], default: (3, 3, 3)
| Determines the size of the kernel along the xyz-axes. Only non-singleton dimensions
| are opened, e.g. a kernel size of ``(3, 3, 1)`` and ``(3, 3, 3)`` produce the same
| result for 2D images.
|
| scalars : str, optional
| Name of scalars to process. Defaults to currently active scalars.
|
| binary : bool | VectorLike[float], optional
| Control if binary opening or continuous opening is used. Refer to
| :meth:`erode` and/or :meth:`dilate` for details about using this keyword.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Dataset that has been opened.
|
| See Also
| --------
| close, erode, dilate
|
| Notes
| -----
| This filter only supports point data. For inputs with cell data, consider
| re-meshing the cell data as point data with
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| or resampling the cell data to point data with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`.
|
| Examples
| --------
| Load a grayscale image :func:`~pyvista.examples.downloads.download_chest()` and show it
| for context.
|
| >>> from pyvista import examples
| >>> im = examples.download_chest()
| >>> clim = im.get_data_range()
| >>> kwargs = dict(
| ... cmap='grey',
| ... clim=clim,
| ... lighting=False,
| ... cpos='xy',
| ... zoom='tight',
| ... show_axes=False,
| ... show_scalar_bar=False,
| ... )
| >>> im.plot(**kwargs)
|
| Use ``open`` to remove small objects in the lungs.
|
| >>> opened = im.open(kernel_size=15)
| >>> opened.plot(**kwargs)
|
| pad_image(self, pad_value: "float | VectorLike[float] | Literal['wrap', 'mirror']" = 0.0, *, pad_size: 'int | VectorLike[int]' = 1, dimensionality: "VectorLike[bool] | Literal[0, 1, 2, 3, '0D', '1D', '2D', '3D', 'preserve']" = 'preserve', scalars: 'str | None' = None, pad_all_scalars: 'bool' = False, progress_bar: 'bool' = False) -> 'ImageData'
| Enlarge an image by padding its boundaries with new points.
|
| .. versionadded:: 0.44.0
|
| Padded points may be mirrored, wrapped, or filled with a constant value. By
| default, all boundaries of the image are padded with a single constant value.
|
| This filter is designed to work with 1D, 2D, or 3D image data and will only pad
| non-singleton dimensions unless otherwise specified.
|
| Parameters
| ----------
| pad_value : float | sequence[float] | 'mirror' | 'wrap', default: 0.0
| Padding value(s) given to new points outside the original image extent.
| Specify:
|
| - a number: New points are filled with the specified constant value.
| - a vector: New points are filled with the specified multi-component vector.
| - ``'wrap'``: New points are filled by wrapping around the padding axis.
| - ``'mirror'``: New points are filled by mirroring the padding axis.
|
| pad_size : int | sequence[int], default: 1
| Number of points to add to the image boundaries. Specify:
|
| - A single value to pad all boundaries equally.
| - Two values, one for each ``(X, Y)`` axis, to apply symmetric padding to
| each axis independently.
| - Three values, one for each ``(X, Y, Z)`` axis, to apply symmetric padding
| to each axis independently.
| - Four values, one for each ``(-X, +X, -Y, +Y)`` boundary, to apply
| padding to each boundary independently.
| - Six values, one for each ``(-X, +X, -Y, +Y, -Z, +Z)`` boundary, to apply
| padding to each boundary independently.
|
| dimensionality : VectorLike[bool], Literal[1, 2, 3, "1D", "2D", "3D", "preserve"]
| Control which dimensions will be padded by the filter.
| ``'preserve'`` is used by default.
|
| - Can be specified as a sequence of 3 boolean to apply padding on a per
| dimension basis.
| - ``1`` or ``'1D'``: apply padding such that the output is a 1D ImageData
| where exactly one dimension is greater than one, e.g. ``(>1, 1, 1)``.
| Only valid for 0D or 1D inputs.
| - ``2`` or ``'2D'``: apply padding such that the output is a 2D ImageData
| where exactly two dimensions are greater than one, e.g. ``(>1, >1, 1)``.
| Only valid for 0D, 1D, or 2D inputs.
| - ``3`` or ``'3D'``: apply padding such that the output is a 3D ImageData,
| where all three dimensions are greater than one, e.g. ``(>1, >1, >1)``.
| Valid for any 0D, 1D, 2D, or 3D inputs.
|
| .. note::
| The ``pad_size`` for singleton dimensions is set to ``0`` by default, even
| if non-zero pad sizes are specified for these axes with this parameter.
| Set ``dimensionality`` to a value different than ``'preserve'`` to
| override this behavior and enable padding any or all dimensions.
|
| .. versionadded:: 0.45.0
|
| scalars : str, optional
| Name of scalars to pad. Defaults to currently active scalars. Unless
| ``pad_all_scalars`` is ``True``, only the specified ``scalars`` are included
| in the output.
|
| pad_all_scalars : bool, default: False
| Pad all point data scalars and include them in the output. This is useful
| for padding images with multiple scalars. If ``False``, only the specified
| ``scalars`` are padded.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Padded image.
|
| See Also
| --------
| crop, resample, contour_labels
|
| Examples
| --------
| Pad a grayscale image with a 100-pixel wide border. The padding is black
| (i.e. has a value of ``0``) by default.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>>
| >>> gray_image = examples.download_moonlanding_image()
| >>> gray_image.dimensions
| (630, 474, 1)
| >>> padded = gray_image.pad_image(pad_size=100)
| >>> padded.dimensions
| (830, 674, 1)
|
| Plot the image. To show grayscale images correctly, we define a custom plotting
| method.
|
| >>> def grayscale_image_plotter(image):
| ... import vtk
| ...
| ... actor = vtk.vtkImageActor()
| ... actor.GetMapper().SetInputData(image)
| ... actor.GetProperty().SetInterpolationTypeToNearest()
| ... pl = pv.Plotter()
| ... pl.add_actor(actor)
| ... pl.view_xy()
| ... pl.camera.tight()
| ... return pl
| >>>
| >>> pl = grayscale_image_plotter(padded)
| >>> pl.show()
|
| Pad only the x-axis with a white border.
|
| >>> padded = gray_image.pad_image(pad_value=255, pad_size=(200, 0))
| >>> pl = grayscale_image_plotter(padded)
| >>> pl.show()
|
| Pad with wrapping.
|
| >>> padded = gray_image.pad_image('wrap', pad_size=100)
| >>> plot = grayscale_image_plotter(padded)
| >>> plot.show()
|
| Pad with mirroring.
|
| >>> padded = gray_image.pad_image('mirror', pad_size=100)
| >>> plot = grayscale_image_plotter(padded)
| >>> plot.show()
|
| Pad a color image using multi-component color vectors. Here, RGBA values are
| used.
|
| >>> color_image = examples.download_beach()
| >>> red = (255, 0, 0) # RGB
| >>> padded = color_image.pad_image(pad_value=red, pad_size=50)
| >>>
| >>> plot_kwargs = dict(cpos='xy', zoom='tight', rgb=True, show_axes=False)
| >>> padded.plot(**plot_kwargs)
|
| Pad each edge of the image separately with a different color.
|
| >>> orange = pv.Color('orange').int_rgb
| >>> purple = pv.Color('purple').int_rgb
| >>> blue = pv.Color('blue').int_rgb
| >>> green = pv.Color('green').int_rgb
| >>>
| >>> padded = color_image.pad_image(orange, pad_size=(25, 0, 0, 0))
| >>> padded = padded.pad_image(purple, pad_size=(0, 25, 0, 0))
| >>> padded = padded.pad_image(blue, pad_size=(0, 0, 25, 0))
| >>> padded = padded.pad_image(green, pad_size=(0, 0, 0, 25))
| >>>
| >>> padded.plot(**plot_kwargs)
|
| points_to_cells(self: 'ImageData', scalars: 'str | None' = None, *, dimensionality: "VectorLike[bool] | Literal[0, 1, 2, 3, '0D', '1D', '2D', '3D', 'preserve']" = 'preserve', copy: 'bool' = True)
| Re-mesh image data from a point-based to a cell-based representation.
|
| This filter changes how image data is represented. Data represented as points
| at the input is re-meshed into an alternative representation as cells at the
| output. Only the :class:`~pyvista.ImageData` container is modified so that
| the number of input points equals the number of output cells. The re-meshing is
| otherwise lossless in the sense that point data at the input is passed through
| unmodified and stored as cell data at the output. Any cell data at the input is
| ignored and is not used by this filter.
|
| To change the image data's representation, the input points are used to
| represent the centers of the output cells. This has the effect of "growing" the
| input image dimensions by one along each axis (i.e. half the cell width on each
| side). For example, an image with 100 points and 99 cells along an axis at the
| input will have 101 points and 100 cells at the output. If the input has 1mm
| spacing, the axis size will also increase from 99mm to 100mm. By default,
| only non-singleton dimensions are increased such that 1D or 2D inputs remain
| 1D or 2D at the output.
|
| Since filters may be inherently cell-based (e.g. some :class:`~pyvista.DataSetFilters`)
| or may operate on point data exclusively (e.g. most :class:`~pyvista.ImageDataFilters`),
| re-meshing enables the same data to be used with either kind of filter while
| ensuring the input data to those filters has the appropriate representation.
| This filter is also useful when plotting image data to achieve a desired visual
| effect, such as plotting images as voxel cells instead of as points.
|
| .. note::
| Only the input's :attr:`~pyvista.ImageData.dimensions`, and
| :attr:`~pyvista.ImageData.origin` are modified by this filter. Other spatial
| properties such as :attr:`~pyvista.ImageData.spacing` and
| :attr:`~pyvista.ImageData.direction_matrix` are not affected.
|
| .. versionadded:: 0.44.0
|
| See Also
| --------
| cells_to_points
| Inverse of this filter to represent cells as points.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample point data as cell data without modifying the container.
| :meth:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| Resample cell data as point data without modifying the container.
|
| Parameters
| ----------
| scalars : str, optional
| Name of point data scalars to pass through to the output as cell data. Use
| this parameter to restrict the output to only include the specified array.
| By default, all point data arrays at the input are passed through as cell
| data at the output.
|
| dimensionality : VectorLike[bool], Literal[0, 1, 2, 3, "0D", "1D", "2D", "3D", "preserve"]
| Control which dimensions will be modified by the filter.
| ``'preserve'`` is used by default.
|
| - Can be specified as a sequence of 3 boolean to allow modification on a per
| dimension basis.
| - ``0`` or ``'0D'``: convenience alias to output a 0D ImageData with
| dimensions ``(1, 1, 1)``. Only valid for 0D inputs.
| - ``1`` or ``'1D'``: convenience alias to output a 1D ImageData where
| exactly one dimension is greater than one, e.g. ``(>1, 1, 1)``. Only valid
| for 0D or 1D inputs.
| - ``2`` or ``'2D'``: convenience alias to output a 2D ImageData where
| exactly two dimensions are greater than one, e.g. ``(>1, >1, 1)``. Only
| valid for 0D, 1D, or 2D inputs.
| - ``3`` or ``'3D'``: convenience alias to output a 3D ImageData, where all
| three dimensions are greater than one, e.g. ``(>1, >1, >1)``. Valid for
| any 0D, 1D, 2D, or 3D inputs.
| - ``'preserve'`` (default): convenience alias to not modify singleton
| dimensions.
|
| copy : bool, default: True
| Copy the input point data before associating it with the output cell data.
| If ``False``, the input and output will both refer to the same data array(s).
|
| Returns
| -------
| pyvista.ImageData
| Image with a cell-based representation.
|
| Examples
| --------
| Load an image with point data.
|
| >>> from pyvista import examples
| >>> image = examples.load_uniform()
|
| Show the current properties and point arrays of the image.
|
| >>> image
| ImageData (...)
| N Cells: 729
| N Points: 1000
| X Bounds: 0.000e+00, 9.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| Dimensions: 10, 10, 10
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 2
|
| >>> image.point_data.keys()
| ['Spatial Point Data']
|
| Re-mesh the points and point data as cells and cell data.
|
| >>> cells_image = image.points_to_cells()
|
| Show the properties and cell arrays of the re-meshed image.
|
| >>> cells_image
| ImageData (...)
| N Cells: 1000
| N Points: 1331
| X Bounds: -5.000e-01, 9.500e+00
| Y Bounds: -5.000e-01, 9.500e+00
| Z Bounds: -5.000e-01, 9.500e+00
| Dimensions: 11, 11, 11
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> cells_image.cell_data.keys()
| ['Spatial Point Data']
|
| Observe that:
|
| - The input point array is now a cell array
| - The output has one less array (the input cell data is ignored)
| - The dimensions have increased by one
| - The bounds have increased by half the spacing
| - The output ``N Cells`` equals the input ``N Points``
|
| Since the input points are 3D (i.e. there are no singleton dimensions), the
| output cells are 3D :attr:`~pyvista.CellType.VOXEL` cells.
|
| >>> cells_image.get_cell(0).type
| <CellType.VOXEL: 11>
|
| If the input points are 2D (i.e. one dimension is singleton), the
| output cells are 2D :attr:`~pyvista.CellType.PIXEL` cells when ``dimensions`` is
| set to ``'preserve'``.
|
| >>> image2D = examples.download_beach()
| >>> image2D.dimensions
| (100, 100, 1)
|
| >>> pixel_cells_image = image2D.points_to_cells(dimensionality='preserve')
| >>> pixel_cells_image.dimensions
| (101, 101, 1)
| >>> pixel_cells_image.get_cell(0).type
| <CellType.PIXEL: 8>
|
| This is equivalent as requesting a 2D output.
|
| >>> pixel_cells_image = image2D.points_to_cells(dimensionality='2D')
| >>> pixel_cells_image.dimensions
| (101, 101, 1)
| >>> pixel_cells_image.get_cell(0).type
| <CellType.PIXEL: 8>
|
| Use ``(True, True, True)`` to re-mesh 2D points as 3D cells.
|
| >>> voxel_cells_image = image2D.points_to_cells(
| ... dimensionality=(True, True, True)
| ... )
| >>> voxel_cells_image.dimensions
| (101, 101, 2)
| >>> voxel_cells_image.get_cell(0).type
| <CellType.VOXEL: 11>
|
| Or request a 3D output.
|
| >>> voxel_cells_image = image2D.points_to_cells(dimensionality='3D')
| >>> voxel_cells_image.dimensions
| (101, 101, 2)
| >>> voxel_cells_image.get_cell(0).type
| <CellType.VOXEL: 11>
|
| See :ref:`image_representations_example` for more examples using this filter.
|
| resample(self: 'ImageData', sample_rate: 'float | VectorLike[float] | None' = None, interpolation: '_InterpolationOptions' = 'nearest', *, border_mode: "Literal['clamp', 'wrap', 'mirror']" = 'clamp', reference_image: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, anti_aliasing: 'bool' = False, extend_border: 'bool | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Resample the image to modify its dimensions and spacing.
|
| The resampling can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_image``.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``sample_rate`` explicitly.
|
| Use ``reference_image`` for full control of the resampled geometry. For
| all other options, the geometry is implicitly defined such that the resampled
| image fits the bounds of the input.
|
| This filter may be used to resample either point or cell data. For point data,
| this filter assumes the data is from discrete samples in space which represent
| pixels or voxels; the resampled bounds are therefore extended by 1/2 voxel
| spacing by default though this may be disabled.
|
| .. note::
|
| Singleton dimensions are not resampled by this filter, e.g. 2D images
| will remain 2D.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| sample_rate : float | VectorLike[float], optional
| Sampling rate(s) to use. Can be a single value or vector of three values
| for each axis. Values greater than ``1.0`` will up-sample the axis and
| values less than ``1.0`` will down-sample it. Values must be greater than ``0``.
|
| interpolation : 'nearest', 'linear', 'cubic', 'lanczos', 'hamming', 'blackman', 'bspline'
| Interpolation mode to use.
|
| - ``'nearest'`` (default) duplicates (if upsampling) or removes (if downsampling)
| values but does not modify them.
| - ``'linear'`` and ``'cubic'`` use linear and cubic interpolation, respectively.
| - ``'lanczos'``, ``'hamming'``, and ``'blackman'`` use a windowed sinc filter
| and may be used to preserve sharp details and/or reduce image artifacts.
| - ``'bspline'`` uses an n-degree basis spline to smoothly interpolate across points.
| The default degree is ``3``, but can range from ``0`` to ``9``. Append the desired
| degree to the string to set it, e.g. ``'bspline5'`` for a 5th-degree B-spline.
|
| .. versionadded:: 0.47
| Added ``'bspline'`` interpolation.
|
| .. note::
|
| - use ``'nearest'`` for pixel art or categorical data such as segmentation masks
| - use ``'linear'`` for speed-critical tasks
| - use ``'cubic'`` for upscaling or general-purpose resampling
| - use ``'lanczos'`` for high-detail downsampling (at the cost of some ringing)
| - use ``'blackman'`` for minimizing ringing artifacts (at the cost of some detail)
| - use ``'hamming'`` for a balance between detail-preservation and reducing ringing
|
| border_mode : 'clamp' | 'wrap' | 'mirror', default: 'clamp'
| Controls the interpolation at the image's borders.
|
| - ``'clamp'`` - values outside the image are clamped to the nearest edge.
| - ``'wrap'`` - values outside the image are wrapped periodically along the axis.
| - ``'mirror'`` - values outside the image are mirrored at the boundary.
|
| .. versionadded:: 0.47
|
| reference_image : ImageData, optional
| Reference image to use. If specified, the input is resampled
| to match the geometry of the reference. The :attr:`~pyvista.ImageData.dimensions`,
| :attr:`~pyvista.ImageData.spacing`, :attr:`~pyvista.ImageData.origin`,
| :attr:`~pyvista.ImageData.offset`, and :attr:`~pyvista.ImageData.direction_matrix`
| of the resampled image will all match the reference image.
|
| dimensions : VectorLike[int], optional
| Set the output :attr:`~pyvista.ImageData.dimensions` of the resampled image.
|
| .. note::
|
| Dimensions is the number of `points` along each axis. If resampling
| `cell` data, each dimension should be one more than the number of
| desired output cells (since there are ``N`` cells and ``N+1`` points
| along each axis). See examples.
|
| anti_aliasing : bool, default: False
| Enable antialiasing. This will blur the image as part of the resampling
| to reduce image artifacts when down-sampling. Has no effect when up-sampling.
|
| extend_border : bool, optional
| Extend the apparent input border by approximately half the
| :attr:`~pyvista.ImageData.spacing`. If enabled, the bounds of the
| resampled points will be larger than the input image bounds.
| Enabling this option also has the effect that the re-sampled spacing
| will directly correlate with the resampled dimensions, e.g. if
| the dimensions are doubled the spacing will be halved. See examples.
|
| This option is enabled by default when resampling point data. Has no effect
| when resampling cell data or when a ``reference_image`` is provided.
|
| scalars : str, optional
| Name of scalars to resample. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When scalars is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| inplace : bool, default: False
| If ``True``, resample the image inplace. By default, a new
| :class:`~pyvista.ImageData` instance is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Resampled image.
|
| See Also
| --------
| crop
| Crop image to remove points at the image's boundaries.
|
| :meth:`~pyvista.DataObjectFilters.sample`
| Resample array data from one mesh onto another.
|
| :meth:`~pyvista.DataSetFilters.interpolate`
| Interpolate values from one mesh onto another.
|
| :ref:`image_representations_example`
| Compare images represented as points vs. cells.
|
| Examples
| --------
| Create a small 2D grayscale image with dimensions ``3 x 2`` for demonstration.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> from pyvista import examples
| >>> image = pv.ImageData(dimensions=(3, 2, 1))
| >>> image.point_data['data'] = np.linspace(0, 255, 6, dtype=np.uint8)
|
| Define a custom plotter to show the image. Although the image data is defined
| as point data, we use :meth:`points_to_cells` to display the image as
| :attr:`~pyvista.CellType.PIXEL` (or :attr:`~pyvista.CellType.VOXEL`) cells
| instead. Grayscale coloring is used and the camera is adjusted to fit the image.
|
| >>> def image_plotter(image: pv.ImageData, clim=(0, 255)) -> pv.Plotter:
| ... pl = pv.Plotter()
| ... image = image.points_to_cells()
| ... pl.add_mesh(
| ... image,
| ... lighting=False,
| ... show_edges=True,
| ... cmap='grey',
| ... clim=clim,
| ... show_scalar_bar=False,
| ... line_width=3,
| ... )
| ... pl.view_xy()
| ... pl.camera.tight()
| ... pl.enable_anti_aliasing()
| ... return pl
|
| Show the image.
|
| >>> plot = image_plotter(image)
| >>> plot.show()
|
| Use ``sample_rate`` to up-sample the image. ``'nearest'`` interpolation is
| used by default.
|
| >>> upsampled = image.resample(sample_rate=2.0)
| >>> plot = image_plotter(upsampled)
| >>> plot.show()
|
| Use ``'linear'`` interpolation. Note that the argument names ``sample_rate``
| and ``interpolation`` may be omitted.
|
| >>> upsampled = image.resample(2.0, 'linear')
| >>> plot = image_plotter(upsampled)
| >>> plot.show()
|
| Use ``'cubic'`` interpolation. Here we also specify the output
| ``dimensions`` explicitly instead of using ``sample_rate``.
|
| >>> upsampled = image.resample(dimensions=(6, 4, 1), interpolation='cubic')
| >>> plot = image_plotter(upsampled)
| >>> plot.show()
|
| Compare the relative physical size of the image before and after resampling.
|
| >>> image
| ImageData (...)
| N Cells: 2
| N Points: 6
| X Bounds: 0.000e+00, 2.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 3, 2, 1
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> upsampled
| ImageData (...)
| N Cells: 15
| N Points: 24
| X Bounds: -2.500e-01, 2.250e+00
| Y Bounds: -2.500e-01, 1.250e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 6, 4, 1
| Spacing: 5.000e-01, 5.000e-01, 1.000e+00
| N Arrays: 1
|
| Note that the upsampled :attr:`~pyvista.ImageData.dimensions` are doubled and
| the :attr:`~pyvista.ImageData.spacing` is halved (as expected). Also note,
| however, that the physical bounds of the input differ from the output.
| The upsampled :attr:`~pyvista.ImageData.origin` also differs:
|
| >>> image.origin
| (0.0, 0.0, 0.0)
| >>> upsampled.origin
| (-0.25, -0.25, 0.0)
|
| This is because the resampling is done with ``extend_border`` enabled by default
| which adds a half cell-width border to the image and adjusts the origin and
| spacing such that the bounds match when the image is represented as cells.
|
| Apply :meth:`points_to_cells` to the input and resampled images and show that
| the bounds match.
|
| >>> image_as_cells = image.points_to_cells()
| >>> image_as_cells.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = 0.0,
| z_max = 0.0)
|
| >>> upsampled_as_cells = upsampled.points_to_cells()
| >>> upsampled_as_cells.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = 0.0,
| z_max = 0.0)
|
| Plot the two images together as wireframe to visualize them. The original is in
| red, and the resampled image is in black.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... image_as_cells, style='wireframe', color='red', line_width=10
| ... )
| >>> _ = pl.add_mesh(
| ... upsampled_as_cells, style='wireframe', color='black', line_width=2
| ... )
| >>> pl.view_xy()
| >>> pl.camera.tight()
| >>> pl.show()
|
| Disable ``extend_border`` to force the input and output bounds of the points
| to be the same instead.
|
| >>> upsampled = image.resample(sample_rate=2, extend_border=False)
|
| Compare the two images again.
|
| >>> image
| ImageData (...)
| N Cells: 2
| N Points: 6
| X Bounds: 0.000e+00, 2.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 3, 2, 1
| Spacing: 1.000e+00, 1.000e+00, 1.000e+00
| N Arrays: 1
|
| >>> upsampled
| ImageData (...)
| N Cells: 15
| N Points: 24
| X Bounds: 0.000e+00, 2.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| Dimensions: 6, 4, 1
| Spacing: 4.000e-01, 3.333e-01, 1.000e+00
| N Arrays: 1
|
| This time the input and output bounds match without any further processing.
| Like before, the dimensions have doubled; unlike before, however, the spacing is
| not halved, but is instead smaller than half which is necessary to ensure the
| bounds remain the same. Also unlike before, the origin is unaffected:
|
| >>> image.origin
| (0.0, 0.0, 0.0)
| >>> upsampled.origin
| (0.0, 0.0, 0.0)
|
| All the above examples are with 2D images with point data. However, the filter
| also works with 3D volumes and will also work with cell data.
|
| Convert the 2D image with point data into a 3D volume with cell data and plot
| it for context.
|
| >>> volume = image.points_to_cells(dimensionality='3D')
| >>> volume.plot(show_edges=True, cmap='grey')
|
| Up-sample the volume. Set the sampling rate for each axis separately.
|
| >>> resampled = volume.resample(sample_rate=(3.0, 2.0, 1.0))
| >>> resampled.plot(show_edges=True, cmap='grey')
|
| Alternatively, we could have set the dimensions explicitly. Since we want
| ``9 x 4 x 1`` cells along the x-y-z axes (respectively), we set the dimensions
| to ``(10, 5, 2)``, i.e. one more than the desired number of cells.
|
| >>> resampled = volume.resample(dimensions=(10, 5, 2))
| >>> resampled.plot(show_edges=True, cmap='grey')
|
| Compare the bounds before and after resampling. Unlike with point data, the
| bounds are not (and cannot be) extended.
|
| >>> volume.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = -0.5,
| z_max = 0.5)
| >>> resampled.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 2.5,
| y_min = -0.5,
| y_max = 1.5,
| z_min = -0.5,
| z_max = 0.5)
|
| Use a reference image to control the resampling instead. Here we load two
| images with different dimensions:
| :func:`~pyvista.examples.downloads.download_bird` and
| :func:`~pyvista.examples.downloads.download_gourds`.
|
| >>> bird = examples.download_bird()
| >>> bird.dimensions
| (458, 342, 1)
|
| >>> gourds = examples.download_gourds()
| >>> gourds.dimensions
| (640, 480, 1)
|
| Use ``reference_image`` to resample the bird to match the gourds geometry or
| vice-versa.
|
| >>> bird_resampled = bird.resample(reference_image=gourds)
| >>> bird_resampled.dimensions
| (640, 480, 1)
|
| >>> gourds_resampled = gourds.resample(reference_image=bird)
| >>> gourds_resampled.dimensions
| (458, 342, 1)
|
| Downsample the gourds image to 1/10th its original resolution using ``'lanczos'``
| interpolation.
|
| >>> downsampled = gourds.resample(1 / 8, 'lanczos')
| >>> downsampled.dimensions
| (80, 60, 1)
|
| Compare the downsampled image to the original and zoom in to show detail.
|
| >>> def compare_images_plotter(image1, image2):
| ... pl = pv.Plotter(shape=(1, 2))
| ... _ = pl.add_mesh(image1, rgba=True, show_edges=False, lighting=False)
| ... pl.subplot(0, 1)
| ... _ = pl.add_mesh(image2, rgba=True, show_edges=False, lighting=False)
| ... pl.link_views()
| ... pl.view_xy()
| ... pl.camera.zoom(3.0)
| ... return pl
|
| >>> pl = compare_images_plotter(gourds, downsampled)
| >>> pl.show()
|
| Note that downsampling can create image artifacts caused by aliasing. Enable
| anti-aliasing to smooth the image before resampling.
|
| >>> downsampled2 = gourds.resample(1 / 8, 'lanczos', anti_aliasing=True)
|
| Compare down-sampling with aliasing (left) to without aliasing (right).
|
| >>> pl = compare_images_plotter(downsampled, downsampled2)
| >>> pl.show()
|
| Load an MRI of a knee and downsample it.
|
| >>> knee = pv.examples.download_knee().resample(
| ... 0.1, 'linear', anti_aliasing=True
| ... )
|
| Crop and plot it.
|
| >>> knee = knee.crop(normalized_bounds=[0.2, 0.8, 0.2, 0.8, 0.0, 1.0])
| >>> vmin = knee.active_scalars.min()
| >>> vmax = knee.active_scalars.max()
| >>> pl = image_plotter(knee, clim=[vmin, vmax])
| >>> pl.show()
|
| Upsample it with B-spline interpolation. The interpolation is very smooth.
|
| >>> upsampled = knee.resample(2.0, 'bspline', border_mode='clamp')
| >>> pl = image_plotter(upsampled, clim=[vmin, vmax])
| >>> pl.show()
|
| Use the ``'wrap'`` border mode. Note how points at the border are brighter than previously,
| since the bright pixels from the opposite edge are now included in the interpolation.
|
| >>> upsampled = knee.resample(2.0, 'bspline', border_mode='wrap')
| >>> pl = image_plotter(upsampled, clim=[vmin, vmax])
| >>> pl.show()
|
| Compare B-spline interpolation to ``'hamming'``.
|
| >>> upsampled = knee.resample(2.0, 'hamming')
| >>> pl = image_plotter(upsampled, clim=[vmin, vmax])
| >>> pl.show()
|
| rfft(self, output_scalars_name=None, progress_bar: 'bool' = False)
| Apply a reverse fast Fourier transform (RFFT) to the active scalars.
|
| The input can be real or complex data, but the output is always
| :attr:`numpy.complex128`. The filter is fastest for images that have power
| of two sizes.
|
| The filter uses a butterfly diagram for each prime factor of the
| dimension. This makes images with prime number dimensions (i.e. 17x17)
| much slower to compute. FFTs of multidimensional meshes (i.e volumes)
| are decomposed so that each axis executes serially.
|
| The frequencies of the input assume standard order: along each axis
| first positive frequencies are assumed from 0 to the maximum, then
| negative frequencies are listed from the largest absolute value to
| smallest. This implies that the corners of the grid correspond to low
| frequencies, while the center of the grid corresponds to high
| frequencies.
|
| Parameters
| ----------
| output_scalars_name : str, optional
| The name of the output scalars. By default, this is the same as the
| active scalars of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| :class:`pyvista.ImageData` with the applied reverse FFT.
|
| See Also
| --------
| fft : The direct transform.
| low_pass : Low-pass filtering of FFT output.
| high_pass : High-pass filtering of FFT output.
|
| Examples
| --------
| Apply reverse FFT to an example image.
|
| >>> from pyvista import examples
| >>> image = examples.download_moonlanding_image()
| >>> fft_image = image.fft()
| >>> image_again = fft_image.rfft()
| >>> image_again.point_data # doctest:+SKIP
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : PNGImage
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| PNGImage complex128 (298620,) SCALARS
|
| See :ref:`image_fft_example` for a full example using this filter.
|
| select_values(self: 'ImageData', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, fill_value: 'float | VectorLike[float]' = 0, replacement_value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, split: 'bool' = False)
| Select values of interest and fill the rest with a constant.
|
| Point or cell data may be selected with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to select a single label or groups
| of labels from categorical data, or to select multiple regions from continuous
| data. Selected values may optionally be split into separate meshes.
|
| The selected values are stored in an array with the same name as the input.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to select. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When selecting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to select. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| selection. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to select values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to select values less than or equal to zero.
|
| fill_value : float | VectorLike[float] | None, default: 0
| Value used to fill the image. Can be a single value or a multi-component
| vector. Non-selected parts of the image will have this value. Set this to
| ``None`` to keep the input array's original values for non-selected regions.
|
| replacement_value : float | VectorLike[float], optional
| Replacement value for the output array. Can be a single value or a
| multi-component vector. If provided, selected values will be replaced with
| the given value. If no value is given, the selected values are retained and
| returned as-is. Setting this value is useful for generating a binarized
| output array.
|
| scalars : str, optional
| Name of scalars to select from. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the selection. If ``True`` values are selected which do *not* have
| the specified values.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| selected independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain meshes with only the ``fill_value`` if no
| values meet the selection criteria.
|
| See Also
| --------
| image_threshold
| Similar filter for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Similar threshold-like filter for extracting values from any dataset.
| :meth:`~pyvista.DataSetFilters.split_values`
| Split a mesh by value into separate meshes.
| :meth:`~pyvista.DataSetFilters.threshold`
| Generalized thresholding filter which returns a :class:`~pyvista.UnstructuredGrid`.
|
| Returns
| -------
| output : pyvista.ImageData | pyvista.MultiBlock
| Image with selected values or a composite of meshes with selected
| values, depending on ``split``.
|
| Examples
| --------
| Load a CT image. Here we load
| :func:`~pyvista.examples.downloads.download_whole_body_ct_male`.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.download_whole_body_ct_male()
| >>> ct_image = dataset['ct']
|
| Show the initial data range.
|
| >>> ct_image.get_data_range()
| (np.int16(-1348), np.int16(3409))
|
| Select intensity values above ``150`` to select the bones.
|
| >>> bone_range = [150, float('inf')]
| >>> fill_value = -1000 # fill with intensity values corresponding to air
| >>> bone_image = ct_image.select_values(
| ... ranges=bone_range, fill_value=fill_value
| ... )
|
| Show the new data range.
|
| >>> bone_image.get_data_range()
| (np.int16(-1000), np.int16(3409))
|
| Plot the selected values. Use ``'foreground'`` opacity to make the fill value
| transparent and the selected values opaque.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_volume(
| ... bone_image,
| ... opacity='foreground',
| ... cmap='bone',
| ... )
| >>> pl.view_zx()
| >>> pl.camera.up = (0, 0, 1)
| >>> pl.show()
|
| Use ``'replacement_value'`` to binarize the selected values instead. The fill
| value, or background, is ``0`` by default.
|
| >>> bone_mask = ct_image.select_values(ranges=bone_range, replacement_value=1)
| >>> bone_mask.get_data_range()
| (np.int16(0), np.int16(1))
|
| Generate a surface contour of the mask and plot it.
|
| >>> surf = bone_mask.contour_labels()
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(surf, color=True)
| >>> pl.view_zx()
| >>> pl.camera.up = (0, 0, 1)
| >>> pl.show()
|
| Load a color image. Here we load :func:`~pyvista.examples.downloads.download_beach`.
|
| >>> image = examples.download_beach()
| >>> plot_kwargs = dict(
| ... cpos='xy', rgb=True, lighting=False, zoom='tight', show_axes=False
| ... )
| >>> image.plot(**plot_kwargs)
|
| Select components from the image which have a strong red component.
| Use ``replacement_value`` to replace these pixels with a pure red color
| and ``fill_value`` to fill the rest of the image with white pixels.
|
| >>> white = [255, 255, 255]
| >>> red = [255, 0, 0]
| >>> red_range = [200, 255]
| >>> red_component = 0
| >>> selected = image.select_values(
| ... ranges=red_range,
| ... component_mode=red_component,
| ... replacement_value=red,
| ... fill_value=white,
| ... )
|
| >>> selected.plot(**plot_kwargs)
|
| slice_index(self: 'ImageData', i: 'int | VectorLike[int] | slice | None' = None, j: 'int | VectorLike[int] | slice | None' = None, k: 'int | VectorLike[int] | slice | None' = None, *, index_mode: "Literal['extent', 'dimensions']" = 'dimensions', strict_index: 'bool' = False, rebase_coordinates: 'bool' = False, progress_bar: 'bool' = False) -> 'ImageData'
| Extract a subset using IJK indices.
|
| This filter enables slicing :class:`~pyvista.ImageData` with Python-style indexing using
| IJK coordinates. It can be used to extract a single slice, multiple contiguous slices, or
| a volume of interest. Unlike other slicing filters, this filter returns
| :class:`~pyvista.ImageData`.
|
| .. note::
| Slicing by index is also possible using the "get index" operator ``[]``. See examples.
|
| .. versionadded::0.46
|
| Parameters
| ----------
| i, j, k : int | VectorLike[int] | slice, optional
| Indices to slice along the I, J, and K coordinate axes, respectively. Specify an
| integer for a single index, or two integers ``[start, stop)`` for a range of indices.
|
| .. note::
|
| Like regular Python slicing:
|
| - Half-open intervals are used, i.e. the ``start`` index is included in the range
| but the ``stop`` index is not.
| - Negative indexing is supported.
| - An ``IndexError`` is raised when a single integer is specified as the index and
| the index is out-of-bounds.
| - An ``IndexError`` is `not` raised when a range is specified as the index and
| the index is out-of-bounds. This default can be overridden by setting
| ``strict_index=True``.
| - A copy of the data is returned (modifying the sliced output does `not` affect
| the input data).
|
| index_mode : 'extent' | 'dimensions', default: 'dimensions'
| Mode to use when determining the range of values to index from.
|
| - Use ``'dimensions'`` to index values in the range ``[0, dimensions - 1]``.
| - Use ``'extent'`` to index values based on the :class:`~pyvista.ImageData.extent`,
| i.e. ``[offset, offset + dimensions - 1]``.
|
| The main difference between these modes is the inclusion or exclusion of the
| :attr:`~pyvista.ImageData.offset`. ``dimensions`` is more pythonic and is how the
| object's data arrays themselves would be indexed, whereas ``'extent'`` respects VTK's
| definition of ``extent`` and considers the object's geometry.
|
| strict_index : bool, default: False
| Raise an ``IndexError`` if `any` of the indices are out of range. By default, an
| ``IndexError`` is only raised if a single integer index is out of range, but not when
| a range of indices are specified; set this to ``True`` to raise in error in both cases.
|
| rebase_coordinates : bool, default: False
| Rebase the coordinate reference of the extracted subset:
|
| - the :attr:`~pyvista.ImageData.origin` is set to the minimum bounds of the subset
| - the :attr:`~pyvista.ImageData.offset` is reset to ``(0, 0, 0)``
|
| The rebasing effectively applies a positive translation in world (XYZ) coordinates and
| a similar (i.e. inverse) negative translation in voxel (IJK) coordinates. As a result,
| the :attr:`~pyvista.DataSet.bounds` of the output are unchanged, but the coordinate
| reference frame is modified.
|
| Set this to ``False`` to leave the origin unmodified and keep the offset specified by
| the indexing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Sliced mesh.
|
| See Also
| --------
| crop
| extract_subset
| :meth:`~pyvista.DataObjectFilters.slice`
| :meth:`~pyvista.DataObjectFilters.slice_implicit`
| :meth:`~pyvista.DataObjectFilters.slice_orthogonal`
| :meth:`~pyvista.DataObjectFilters.slice_along_axis`
| :meth:`~pyvista.DataObjectFilters.slice_along_line`
|
| Examples
| --------
| Create a :class:`~pyvista.ImageData` mesh and give it some point data.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(10, 10, 10))
| >>> mesh['data'] = range(mesh.n_points)
|
| Extract a single slice along the k-axis.
|
| >>> sliced = mesh.slice_index(k=5)
| >>> sliced.dimensions
| (10, 10, 1)
|
| Equivalently:
|
| >>> sliced2 = mesh[:, :, 5]
| >>> sliced == sliced2
| True
|
| Extract a volume of interest.
|
| >>> sliced = mesh.slice_index(i=[1, 3], j=[2, 5], k=[5, 10])
| >>> sliced.dimensions
| (2, 3, 5)
|
| Equivalently:
|
| >>> sliced2 = mesh[1:3, 2:5, 5:10]
| >>> sliced == sliced2
| True
|
| Use ``None`` to implicitly define the start and/or stop indices.
|
| >>> sliced = mesh.slice_index(i=[None, 3], j=[2, None], k=None)
| >>> sliced.dimensions
| (3, 8, 10)
|
| Equivalently:
|
| >>> sliced2 = mesh[:3, 2:, :]
| >>> sliced == sliced2
| True
|
| See :ref:`slice_example` for more examples using this filter.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkImageData:
|
| AllocateScalars(...)
| AllocateScalars(self, dataType:int, numComponents:int) -> None
| C++: virtual void AllocateScalars(int dataType, int numComponents)
| AllocateScalars(self, pipeline_info:vtkInformation) -> None
| C++: virtual void AllocateScalars(vtkInformation *pipeline_info)
|
| Allocate the point scalars for this dataset. The data type
| determines the type of the array (VTK_FLOAT, VTK_INT etc.) where
| as numComponents determines its number of components.
|
| ApplyIndexToPhysicalMatrix(...)
| ApplyIndexToPhysicalMatrix(self, source:vtkMatrix4x4) -> None
| C++: void ApplyIndexToPhysicalMatrix(vtkMatrix4x4 *source)
|
| Set the transformation matrix from the index space to the
| physical space coordinate system of the dataset. The transform is
| a 4 by 4 matrix. The supplied matrix pointer is not stored in the
| the image object but the matrix values are used for updating the
| Origin, Spacing, and DirectionMatrix.
| \sa SetOrigin
| \sa SetSpacing
| \sa SetDirectionMatrix
|
| ApplyPhysicalToIndexMatrix(...)
| ApplyPhysicalToIndexMatrix(self, source:vtkMatrix4x4) -> None
| C++: void ApplyPhysicalToIndexMatrix(vtkMatrix4x4 *source)
|
| Get the transformation matrix from the physical space to the
| index space coordinate system of the dataset. The transform is a
| 4 by 4 matrix. The supplied matrix pointer is not stored in the
| the image object but the matrix values are used for updating the
| Origin, Spacing, and DirectionMatrix.
| \sa SetOrigin
| \sa SetSpacing
| \sa SetDirectionMatrix
|
| ComputeBounds(...)
| ComputeBounds(self) -> None
| C++: void ComputeBounds() override;
|
| Compute the data bounding box from data points. THIS METHOD IS
| NOT THREAD SAFE.
|
| ComputeCellId(...)
| ComputeCellId(self, ijk:[int, int, int]) -> int
| C++: vtkIdType ComputeCellId(int ijk[3]) override;
|
| Given a location in structured coordinates (i-j-k), return the
| cell id. Rely on vtkStructuredData::ComputeCellIdForExtent
|
| ComputeIndexToPhysicalMatrix(...)
| ComputeIndexToPhysicalMatrix(origin:(float, float, float),
| spacing:(float, float, float), direction:(float, float, float,
| float, float, float, float, float, float), result:[float,
| float, float, float, float, float, float, float, float, float,
| float, float, float, float, float, float]) -> None
| C++: static void ComputeIndexToPhysicalMatrix(
| double const origin[3], double const spacing[3],
| double const direction[9], double result[16])
|
| Static method to compute the IndexToPhysicalMatrix.
|
| ComputeInternalExtent(...)
| ComputeInternalExtent(self, intExt:[int, ...], tgtExt:[int, ...],
| bnds:[int, ...]) -> None
| C++: void ComputeInternalExtent(int *intExt, int *tgtExt,
| int *bnds)
|
| Given how many pixel are required on a side for boundary
| conditions (in bnds), the target extent to traverse, compute the
| internal extent (the extent for this ImageData that does not
| suffer from any boundary conditions) and place it in intExt
|
| ComputePhysicalToIndexMatrix(...)
| ComputePhysicalToIndexMatrix(origin:(float, float, float),
| spacing:(float, float, float), direction:(float, float, float,
| float, float, float, float, float, float), result:[float,
| float, float, float, float, float, float, float, float, float,
| float, float, float, float, float, float]) -> None
| C++: static void ComputePhysicalToIndexMatrix(
| double const origin[3], double const spacing[3],
| double const direction[9], double result[16])
|
| Static method to compute the PhysicalToIndexMatrix.
|
| ComputePointId(...)
| ComputePointId(self, ijk:[int, int, int]) -> int
| C++: vtkIdType ComputePointId(int ijk[3]) override;
|
| Given a location in structured coordinates (i-j-k), return the
| point id. Rely on vtkStructuredData::ComputePointIdForExtent
|
| ComputeStructuredCoordinates(...)
| ComputeStructuredCoordinates(self, x:(float, float, float),
| ijk:[int, int, int], pcoords:[float, float, float]) -> int
| C++: int ComputeStructuredCoordinates(const double x[3],
| int ijk[3], double pcoords[3]) override;
| ComputeStructuredCoordinates(self, x:(float, float, float),
| ijk:[int, int, int], pcoords:[float, float, float],
| tol2:float) -> int
| C++: virtual int ComputeStructuredCoordinates(const double x[3],
| int ijk[3], double pcoords[3], double tol2)
|
| Computes the structured coordinates for a point x[3]. The voxel
| is specified by the array ijk[3], and the parametric coordinates
| in the cell are specified with pcoords[3]. The function returns a
| 0 if the point x is outside of the volume, and a 1 if inside the
| volume, using squared tolerance tol2 (1e-12 if not provided).
|
| CopyAndCastFrom(...)
| CopyAndCastFrom(self, inData:vtkImageData, extent:[int, int, int,
| int, int, int]) -> None
| C++: virtual void CopyAndCastFrom(vtkImageData *inData,
| int extent[6])
| CopyAndCastFrom(self, inData:vtkImageData, x0:int, x1:int, y0:int,
| y1:int, z0:int, z1:int) -> None
| C++: virtual void CopyAndCastFrom(vtkImageData *inData, int x0,
| int x1, int y0, int y1, int z0, int z1)
|
| This method is passed a input and output region, and executes the
| filter algorithm to fill the output from the input. It just
| executes a switch statement to call the correct function for the
| regions data types.
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, information:vtkInformation)
| -> None
| C++: void CopyInformationFromPipeline(vtkInformation *information)
| override;
|
| Override these to handle origin, spacing, scalar type, and scalar
| number of components. See vtkDataObject for details.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, information:vtkInformation)
| -> None
| C++: void CopyInformationToPipeline(vtkInformation *information)
| override;
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect the image to
| a pipeline.
|
| CopyStructure(...)
| CopyStructure(self, ds:vtkDataSet) -> None
| C++: void CopyStructure(vtkDataSet *ds) override;
|
| Copy the geometric and topological structure of an input image
| data object.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: void Crop(const int *updateExtent) override;
|
| Reallocates and copies to set the Extent to updateExtent. This is
| used internally when the exact extent is requested, and the
| source generated more than the update extent.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| ExtendedNew(...)
| ExtendedNew() -> vtkImageData
| C++: static vtkImageData *ExtendedNew()
|
| FindCell(...)
| FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int,
| tol2:float, subId:int, pcoords:[float, float, float],
| weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
| FindCell(self, x:[float, float, float], cell:vtkCell,
| gencell:vtkGenericCell, cellId:int, tol2:float, subId:int,
| pcoords:[float, float, float], weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkGenericCell *gencell, vtkIdType cellId, double tol2,
| int &subId, double pcoords[3], double *weights) override;
|
| Locate cell based on global coordinate x and tolerance squared.
| If cell and cellId is non-nullptr, then search starts from this
| cell and looks at immediate neighbors. Returns cellId >= 0 if
| inside, < 0 otherwise. The parametric coordinates are provided
| in pcoords[3]. The interpolation weights are returned in
| weights[]. (The number of weights is equal to the number of
| points in the found cell). Tolerance is used to control how close
| the point is to be considered "in" the cell. THIS METHOD IS NOT
| THREAD SAFE.
|
| FindPoint(...)
| FindPoint(self, x:[float, float, float]) -> int
| C++: vtkIdType FindPoint(double x[3]) override;
| FindPoint(self, x:float, y:float, z:float) -> int
| C++: vtkIdType FindPoint(double x, double y, double z)
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated. The
| memory size returned is guaranteed to be greater than or equal to
| the memory required to represent the data (e.g., extra space in
| arrays, etc. are not included in the return value). THIS METHOD
| IS THREAD SAFE.
|
| GetArrayIncrements(...)
| GetArrayIncrements(self, array:vtkDataArray, increments:[int, int,
| int]) -> None
| C++: void GetArrayIncrements(vtkDataArray *array,
| vtkIdType increments[3])
|
| Since various arrays have different number of components, the
| will have different increments.
|
| GetArrayPointer(...)
| GetArrayPointer(self, array:vtkDataArray, coordinates:[int, int,
| int]) -> Pointer
| C++: void *GetArrayPointer(vtkDataArray *array,
| int coordinates[3])
| GetArrayPointer(self, array:vtkDataArray, x:int, y:int, z:int)
| -> Pointer
| C++: void *GetArrayPointer(vtkDataArray *array, int x, int y,
| int z)
|
| GetArrayPointerForExtent(...)
| GetArrayPointerForExtent(self, array:vtkDataArray, extent:[int,
| int, int, int, int, int]) -> Pointer
| C++: void *GetArrayPointerForExtent(vtkDataArray *array,
| int extent[6])
|
| These are convenience methods for getting a pointer from any
| filed array. It is a start at expanding image filters to process
| any array (not just scalars).
|
| GetAxisUpdateExtent(...)
| GetAxisUpdateExtent(self, axis:int, min:int, max:int,
| updateExtent:(int, ...)) -> None
| C++: virtual void GetAxisUpdateExtent(int axis, int &min,
| int &max, const int *updateExtent)
|
| GetCell(...)
| GetCell(self, cellId:int, cell:vtkGenericCell) -> None
| C++: void GetCell(vtkIdType cellId, vtkGenericCell *cell)
| override;
| GetCell(self, cellId:int) -> vtkCell
| C++: vtkCell *GetCell(vtkIdType cellId) override;
| GetCell(self, i:int, j:int, k:int) -> vtkCell
| C++: vtkCell *GetCell(int i, int j, int k) override;
|
| Standard vtkDataSet API methods. See vtkDataSet for more
| information.
|
| GetCellBounds(...)
| GetCellBounds(self, cellId:int, bounds:[float, float, float,
| float, float, float]) -> None
| C++: void GetCellBounds(vtkIdType cellId, double bounds[6])
| override;
|
| Get the bounds of the cell with cellId such that: 0 <= cellId <
| NumberOfCells. A subclass may be able to determine the bounds of
| cell without using an expensive GetCell() method. A default
| implementation is provided that actually uses a GetCell() call.
| This is to ensure the method is available to all datasets.
| Subclasses should override this method to provide an efficient
| implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetContinuousIncrements(...)
| GetContinuousIncrements(self, extent:[int, int, int, int, int,
| int], incX:int, incY:int, incZ:int) -> None
| C++: virtual void GetContinuousIncrements(int extent[6],
| vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ)
| GetContinuousIncrements(self, scalars:vtkDataArray, extent:[int,
| int, int, int, int, int], incX:int, incY:int, incZ:int)
| -> None
| C++: virtual void GetContinuousIncrements(vtkDataArray *scalars,
| int extent[6], vtkIdType &incX, vtkIdType &incY,
| vtkIdType &incZ)
|
| Different ways to get the increments for moving around the data.
| incX is always returned with 0. incY is returned with the
| increment needed to move from the end of one X scanline of data
| to the start of the next line. incZ is filled in with the
| increment needed to move from the end of one image to the start
| of the next. The proper way to use these values is to for a loop
| over Z, Y, X, C, incrementing the pointer by 1 after each
| component. When the end of the component is reached, the pointer
| is set to the beginning of the next pixel, thus incX is properly
| set to 0. The first form of GetContinuousIncrements uses the
| active scalar field while the second form allows the scalar array
| to be passed in.
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkImageData
| C++: static vtkImageData *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkImageData
| C++: static vtkImageData *GetData(vtkInformationVector *v,
| int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return what type of dataset this is.
|
| GetDirectionMatrix(...)
| GetDirectionMatrix(self) -> vtkMatrix3x3
| C++: virtual vtkMatrix3x3 *GetDirectionMatrix()
|
| Set/Get the direction transform of the dataset. The direction
| matrix is a 3x3 transformation matrix supporting scaling and
| rotation.
|
| GetIncrements(...)
| GetIncrements(self) -> (int, int, int)
| C++: virtual vtkIdType *GetIncrements()
| GetIncrements(self, incX:int, incY:int, incZ:int) -> None
| C++: virtual void GetIncrements(vtkIdType &incX, vtkIdType &incY,
| vtkIdType &incZ)
| GetIncrements(self, inc:[int, int, int]) -> None
| C++: virtual void GetIncrements(vtkIdType inc[3])
| GetIncrements(self, scalars:vtkDataArray) -> (int, int, int)
| C++: virtual vtkIdType *GetIncrements(vtkDataArray *scalars)
| GetIncrements(self, scalars:vtkDataArray, incX:int, incY:int,
| incZ:int) -> None
| C++: virtual void GetIncrements(vtkDataArray *scalars,
| vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ)
| GetIncrements(self, scalars:vtkDataArray, inc:[int, int, int])
| -> None
| C++: virtual void GetIncrements(vtkDataArray *scalars,
| vtkIdType inc[3])
|
| Different ways to get the increments for moving around the data.
| GetIncrements() calls ComputeIncrements() to ensure the
| increments are up to date. The first three methods compute the
| increments based on the active scalar field while the next three,
| the scalar field is passed in.
|
| Note that all methods which do not have the increments passed in
| are not thread-safe. When working on a given `vtkImageData`
| instance on multiple threads, each thread should use the `inc*`
| overloads to compute the increments to avoid racing with other
| threads.
|
| GetIndexToPhysicalMatrix(...)
| GetIndexToPhysicalMatrix(self) -> vtkMatrix4x4
| C++: virtual vtkMatrix4x4 *GetIndexToPhysicalMatrix()
|
| Get the transformation matrix from the index space to the
| physical space coordinate system of the dataset. The transform is
| a 4 by 4 matrix.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOrigin(...)
| GetOrigin(self) -> (float, float, float)
| C++: virtual double *GetOrigin()
|
| Set/Get the origin of the dataset. The origin is the position in
| world coordinates of the point of extent (0,0,0). This point does
| not have to be part of the dataset, in other words, the dataset
| extent does not have to start at (0,0,0) and the origin can be
| outside of the dataset bounding box. The origin plus spacing
| determine the position in space of the points.
|
| GetPhysicalToIndexMatrix(...)
| GetPhysicalToIndexMatrix(self) -> vtkMatrix4x4
| C++: virtual vtkMatrix4x4 *GetPhysicalToIndexMatrix()
|
| Get the transformation matrix from the physical space to the
| index space coordinate system of the dataset. The transform is a
| 4 by 4 matrix.
|
| GetPointGradient(...)
| GetPointGradient(self, i:int, j:int, k:int, s:vtkDataArray,
| g:[float, float, float]) -> None
| C++: virtual void GetPointGradient(int i, int j, int k,
| vtkDataArray *s, double g[3])
|
| Given structured coordinates (i,j,k) for a point in a structured
| point dataset, compute the gradient vector from the scalar data
| at that point. The scalars s are the scalars from which the
| gradient is to be computed. This method will treat structured
| point datasets of any dimension.
|
| GetScalarComponentAsDouble(...)
| GetScalarComponentAsDouble(self, x:int, y:int, z:int,
| component:int) -> float
| C++: virtual double GetScalarComponentAsDouble(int x, int y,
| int z, int component)
|
| GetScalarComponentAsFloat(...)
| GetScalarComponentAsFloat(self, x:int, y:int, z:int,
| component:int) -> float
| C++: virtual float GetScalarComponentAsFloat(int x, int y, int z,
| int component)
|
| For access to data from wrappers
|
| GetScalarIndex(...)
| GetScalarIndex(self, coordinates:[int, int, int]) -> int
| C++: virtual vtkIdType GetScalarIndex(int coordinates[3])
| GetScalarIndex(self, x:int, y:int, z:int) -> int
| C++: virtual vtkIdType GetScalarIndex(int x, int y, int z)
|
| GetScalarIndexForExtent(...)
| GetScalarIndexForExtent(self, extent:[int, int, int, int, int,
| int]) -> int
| C++: virtual vtkIdType GetScalarIndexForExtent(int extent[6])
|
| Access the index for the scalar data
|
| GetScalarPointer(...)
| GetScalarPointer(self, coordinates:[int, int, int]) -> Pointer
| C++: virtual void *GetScalarPointer(int coordinates[3])
| GetScalarPointer(self, x:int, y:int, z:int) -> Pointer
| C++: virtual void *GetScalarPointer(int x, int y, int z)
| GetScalarPointer(self) -> Pointer
| C++: virtual void *GetScalarPointer()
|
| GetScalarPointerForExtent(...)
| GetScalarPointerForExtent(self, extent:[int, int, int, int, int,
| int]) -> Pointer
| C++: virtual void *GetScalarPointerForExtent(int extent[6])
|
| Access the native pointer for the scalar data
|
| GetScalarSize(...)
| GetScalarSize(self, meta_data:vtkInformation) -> int
| C++: virtual int GetScalarSize(vtkInformation *meta_data)
| GetScalarSize(self) -> int
| C++: virtual int GetScalarSize()
|
| Get the size of the scalar type in bytes.
|
| GetScalarTypeMax(...)
| GetScalarTypeMax(self, meta_data:vtkInformation) -> float
| C++: virtual double GetScalarTypeMax(vtkInformation *meta_data)
| GetScalarTypeMax(self) -> float
| C++: virtual double GetScalarTypeMax()
|
| GetScalarTypeMin(...)
| GetScalarTypeMin(self, meta_data:vtkInformation) -> float
| C++: virtual double GetScalarTypeMin(vtkInformation *meta_data)
| GetScalarTypeMin(self) -> float
| C++: virtual double GetScalarTypeMin()
|
| These returns the minimum and maximum values the ScalarType can
| hold without overflowing.
|
| GetSpacing(...)
| GetSpacing(self) -> (float, float, float)
| C++: virtual double *GetSpacing()
|
| Set the spacing (width,height,length) of the cubical cells that
| compose the data set.
|
| GetVoxelGradient(...)
| GetVoxelGradient(self, i:int, j:int, k:int, s:vtkDataArray,
| g:vtkDataArray) -> None
| C++: virtual void GetVoxelGradient(int i, int j, int k,
| vtkDataArray *s, vtkDataArray *g)
|
| Given structured coordinates (i,j,k) for a voxel cell, compute
| the eight gradient values for the voxel corners. The order in
| which the gradient vectors are arranged corresponds to the
| ordering of the voxel points. Gradient vector is computed by
| central differences (except on edges of volume where forward
| difference is used). The scalars s are the scalars from which the
| gradient is to be computed. This method will treat only 3D
| structured point datasets (i.e., volumes).
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkImageData
| C++: vtkImageData *NewInstance()
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: void PrepareForNewData() override;
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for image data we leave the
| old data in case the memory can be reused.
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkImageData
| C++: static vtkImageData *SafeDownCast(vtkObjectBase *o)
|
| SetAxisUpdateExtent(...)
| SetAxisUpdateExtent(self, axis:int, min:int, max:int,
| updateExtent:(int, ...), axisUpdateExtent:[int, ...]) -> None
| C++: virtual void SetAxisUpdateExtent(int axis, int min, int max,
| const int *updateExtent, int *axisUpdateExtent)
|
| Set / Get the extent on just one axis
|
| SetDirectionMatrix(...)
| SetDirectionMatrix(self, m:vtkMatrix3x3) -> None
| C++: virtual void SetDirectionMatrix(vtkMatrix3x3 *m)
| SetDirectionMatrix(self, elements:(float, float, float, float,
| float, float, float, float, float)) -> None
| C++: virtual void SetDirectionMatrix(const double elements[9])
| SetDirectionMatrix(self, e00:float, e01:float, e02:float,
| e10:float, e11:float, e12:float, e20:float, e21:float,
| e22:float) -> None
| C++: virtual void SetDirectionMatrix(double e00, double e01,
| double e02, double e10, double e11, double e12, double e20,
| double e21, double e22)
|
| SetOrigin(...)
| SetOrigin(self, i:float, j:float, k:float) -> None
| C++: virtual void SetOrigin(double i, double j, double k)
| SetOrigin(self, ijk:(float, float, float)) -> None
| C++: virtual void SetOrigin(const double ijk[3])
|
| SetScalarComponentFromDouble(...)
| SetScalarComponentFromDouble(self, x:int, y:int, z:int,
| component:int, v:float) -> None
| C++: virtual void SetScalarComponentFromDouble(int x, int y,
| int z, int component, double v)
|
| SetScalarComponentFromFloat(...)
| SetScalarComponentFromFloat(self, x:int, y:int, z:int,
| component:int, v:float) -> None
| C++: virtual void SetScalarComponentFromFloat(int x, int y, int z,
| int component, float v)
|
| SetSpacing(...)
| SetSpacing(self, i:float, j:float, k:float) -> None
| C++: virtual void SetSpacing(double i, double j, double k)
| SetSpacing(self, ijk:(float, float, float)) -> None
| C++: virtual void SetSpacing(const double ijk[3])
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| TransformContinuousIndexToPhysicalPoint(...)
| TransformContinuousIndexToPhysicalPoint(self, i:float, j:float,
| k:float, xyz:[float, float, float]) -> None
| C++: virtual void TransformContinuousIndexToPhysicalPoint(
| double i, double j, double k, double xyz[3])
| TransformContinuousIndexToPhysicalPoint(self, ijk:(float, float,
| float), xyz:[float, float, float]) -> None
| C++: virtual void TransformContinuousIndexToPhysicalPoint(
| const double ijk[3], double xyz[3])
| TransformContinuousIndexToPhysicalPoint(i:float, j:float, k:float,
| origin:(float, float, float), spacing:(float, float, float),
| direction:(float, float, float, float, float, float, float,
| float, float), xyz:[float, float, float]) -> None
| C++: static void TransformContinuousIndexToPhysicalPoint(double i,
| double j, double k, double const origin[3],
| double const spacing[3], double const direction[9],
| double xyz[3])
|
| Convert coordinates from index space (ijk) to physical space
| (xyz).
|
| TransformIndexToPhysicalPoint(...)
| TransformIndexToPhysicalPoint(self, i:int, j:int, k:int,
| xyz:[float, float, float]) -> None
| C++: virtual void TransformIndexToPhysicalPoint(int i, int j,
| int k, double xyz[3])
| TransformIndexToPhysicalPoint(self, ijk:(int, int, int),
| xyz:[float, float, float]) -> None
| C++: virtual void TransformIndexToPhysicalPoint(const int ijk[3],
| double xyz[3])
|
| TransformPhysicalNormalToContinuousIndex(...)
| TransformPhysicalNormalToContinuousIndex(self, xyz:(float, float,
| float), ijk:[float, float, float]) -> None
| C++: virtual void TransformPhysicalNormalToContinuousIndex(
| const double xyz[3], double ijk[3])
|
| Convert normal from physical space (xyz) to index space (ijk).
|
| TransformPhysicalPlaneToContinuousIndex(...)
| TransformPhysicalPlaneToContinuousIndex(self, pplane:(float,
| float, float, float), iplane:[float, float, float, float])
| -> None
| C++: virtual void TransformPhysicalPlaneToContinuousIndex(
| double const pplane[4], double iplane[4])
|
| Convert a plane from physical to a continuous index. The plane is
| represented as n(x-xo)=0; or using a four component normal:
| pplane=( nx,ny,nz,-(n(x0)) ).
|
| TransformPhysicalPointToContinuousIndex(...)
| TransformPhysicalPointToContinuousIndex(self, x:float, y:float,
| z:float, ijk:[float, float, float]) -> None
| C++: virtual void TransformPhysicalPointToContinuousIndex(
| double x, double y, double z, double ijk[3])
| TransformPhysicalPointToContinuousIndex(self, xyz:(float, float,
| float), ijk:[float, float, float]) -> None
| C++: virtual void TransformPhysicalPointToContinuousIndex(
| const double xyz[3], double ijk[3])
|
| Convert coordinates from physical space (xyz) to index space
| (ijk).
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkImageData:
|
| __this__
| Pointer to the C++ object.
|
| data_object_type
| read-only, calls GetDataObjectType
|
| increments
| read-only, calls GetIncrements
|
| scalar_pointer
| read-only, calls GetScalarPointer
|
| scalar_size
| read-only, calls GetScalarSize
|
| scalar_type_max
| read-only, calls GetScalarTypeMax
|
| scalar_type_min
| read-only, calls GetScalarTypeMin
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkImageData:
|
| __vtkname__ = 'vtkImageData'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkCartesianGrid:
|
| BlankCell(...)
| BlankCell(self, ptId:int) -> None
| C++: virtual void BlankCell(vtkIdType ptId)
| BlankCell(self, i:int, j:int, k:int) -> None
| C++: virtual void BlankCell(int i, int j, int k)
|
| Methods for supporting blanking of cells. Blanking turns on or
| off cells in the structured grid. These methods should be called
| only after the dimensions of the grid are set.
|
| BlankPoint(...)
| BlankPoint(self, ptId:int) -> None
| C++: virtual void BlankPoint(vtkIdType ptId)
| BlankPoint(self, i:int, j:int, k:int) -> None
| C++: virtual void BlankPoint(int i, int j, int k)
|
| Methods for supporting blanking of cells. Blanking turns on or
| off points in the structured grid, and hence the cells connected
| to them. These methods should be called only after the dimensions
| of the grid are set.
|
| FindAndGetCell(...)
| FindAndGetCell(self, x:[float, float, float], cell:vtkCell,
| cellId:int, tol2:float, subId:int, pcoords:[float, float,
| float], weights:[float, ...]) -> vtkCell
| C++: vtkCell *FindAndGetCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
|
| Locate the cell that contains a point and return the cell. Also
| returns the subcell id, parametric coordinates and weights for
| subsequent interpolation. This method combines the derived class
| methods int FindCell and vtkCell *GetCell. Derived classes may
| provide a more efficient implementation. See for example
| vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE.
|
| GetCellDims(...)
| GetCellDims(self, cellDims:[int, int, int]) -> None
| C++: void GetCellDims(int cellDims[3])
|
| Given the node dimensions of this grid instance, this method
| computes the node dimensions. The value in each dimension can
| will have a lowest value of "1" such that computing the total
| number of cells can be achieved by simply by
| cellDims[0]*cellDims[1]*cellDims[2].
|
| GetCellNeighbors(...)
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds) override;
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList, seedLoc:[int, ...]) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds, int *seedLoc)
|
| Topological inquiry to get all cells using list of points
| exclusive of cell specified (e.g., cellId). Note that the list
| consists of only cells that use ALL the points provided. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetCellPoints(...)
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...),
| ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts, vtkIdList *ptIds) override;
| GetCellPoints(self, cellId:int, ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
| override;
|
| Topological inquiry to get points defining cell.
|
| This function MAY use ptIds, which is an object that is created
| by each thread, to guarantee thread safety.
|
| @warning Subsequent calls to this method may invalidate previous
| call
| results.
|
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetCellSize(...)
| GetCellSize(self, cellId:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType cellId) override;
|
| Get the size of cell with cellId such that: 0 <= cellId <
| NumberOfCells. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| @warning This method MUST be overridden for performance reasons.
| Default implementation is very inefficient.
|
| GetCellType(...)
| GetCellType(self, cellId:int) -> int
| C++: int GetCellType(vtkIdType cellId) override;
|
| Get type of cell with cellId such that: 0 <= cellId <
| NumberOfCells. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetCellTypes(...)
| GetCellTypes(self) -> vtkConstantArray_IhE
| C++: vtkConstantArray<unsigned char> *GetCellTypes()
| GetCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetCellTypes(vtkCellTypes *types)
|
| GetCellTypesArray(...)
| GetCellTypesArray(self) -> vtkConstantArray_IiE
| C++: vtkConstantArray<int> *GetCellTypesArray()
|
| GetCells(...)
| GetCells(self) -> vtkStructuredCellArray
| C++: vtkStructuredCellArray *GetCells()
|
| Return the image data connectivity array.
|
| NOTE: the returned object should not be modified.
|
| GetDataDescription(...)
| GetDataDescription(self) -> int
| C++: virtual int GetDataDescription()
|
| Get the data description of the rectilinear grid.
|
| GetDataDimension(...)
| GetDataDimension(self) -> int
| C++: int GetDataDimension()
|
| Return the dimensionality of the data.
|
| GetDimensions(...)
| GetDimensions(self) -> (int, int, int)
| C++: int *GetDimensions()
| GetDimensions(self, dims:[int, int, int]) -> None
| C++: void GetDimensions(int dims[3])
| GetDimensions(self, dims:[int, int, int]) -> None
| C++: void GetDimensions(vtkIdType dims[3])
|
| Get dimensions of this structured points dataset. It is the
| number of points on each axis. Dimensions are computed from
| Extents during this call.
| \warning Non thread-safe, use second signature if you want it to
| be.
|
| GetExtent(...)
| GetExtent(self) -> (int, int, int, int, int, int)
| C++: virtual int *GetExtent()
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: int GetExtentType() override;
|
| Structured extent. The extent type is a 3D extent
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Convenience method returns largest cell size in dataset. This is
| generally used to allocate memory for supporting data structures.
| THIS METHOD IS THREAD SAFE
|
| GetMaxSpatialDimension(...)
| GetMaxSpatialDimension(self) -> int
| C++: int GetMaxSpatialDimension() override;
|
| Get the maximum/minimum spatial dimensionality of the data which
| is the maximum/minimum dimension of all cells.
|
| @warning This method MUST be overridden for performance reasons.
| Default implementation is very inefficient.
|
| GetMinSpatialDimension(...)
| GetMinSpatialDimension(self) -> int
| C++: int GetMinSpatialDimension() override;
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| Determine the number of cells composing the dataset. THIS METHOD
| IS THREAD SAFE
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| Determine the number of points composing the dataset. THIS METHOD
| IS THREAD SAFE
|
| GetNumberOfScalarComponents(...)
| GetNumberOfScalarComponents(meta_data:vtkInformation) -> int
| C++: static int GetNumberOfScalarComponents(
| vtkInformation *meta_data)
| GetNumberOfScalarComponents(self) -> int
| C++: int GetNumberOfScalarComponents()
|
| GetPoint(...)
| GetPoint(self, id:int, x:[float, float, float]) -> None
| C++: void GetPoint(vtkIdType id, double x[3]) override;
| GetPoint(self, ptId:int) -> (float, float, float)
| C++: double *GetPoint(vtkIdType ptId) override;
|
| Copy point coordinates into user provided array x[3] for
| specified point id. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetPointCells(...)
| GetPointCells(self, ptId:int, cellIds:vtkIdList) -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
| override;
|
| Topological inquiry to get cells using point. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints() override;
|
| Standard vtkDataSet API methods. See vtkDataSet for more
| information.
|
| GetScalarType(...)
| GetScalarType(meta_data:vtkInformation) -> int
| C++: static int GetScalarType(vtkInformation *meta_data)
| GetScalarType(self) -> int
| C++: int GetScalarType()
|
| GetScalarTypeAsString(...)
| GetScalarTypeAsString(self) -> str
| C++: const char *GetScalarTypeAsString()
|
| GetTupleIndex(...)
| GetTupleIndex(self, array:vtkDataArray, coordinates:[int, int,
| int]) -> int
| C++: vtkIdType GetTupleIndex(vtkDataArray *array,
| int coordinates[3])
| GetTupleIndex(self, array:vtkDataArray, x:int, y:int, z:int)
| -> int
| C++: vtkIdType GetTupleIndex(vtkDataArray *array, int x, int y,
| int z)
|
| GetTupleIndexForExtent(...)
| GetTupleIndexForExtent(self, array:vtkDataArray, extent:[int, int,
| int, int, int, int]) -> int
| C++: vtkIdType GetTupleIndexForExtent(vtkDataArray *array,
| int extent[6])
|
| Given a data array and a coordinate, return the index of the
| tuple in the array corresponding to that coordinate.
|
| GetValueIndex(...)
| GetValueIndex(self, array:vtkDataArray, coordinates:[int, int,
| int]) -> int
| C++: vtkIdType GetValueIndex(vtkDataArray *array,
| int coordinates[3])
| GetValueIndex(self, array:vtkDataArray, x:int, y:int, z:int)
| -> int
| C++: vtkIdType GetValueIndex(vtkDataArray *array, int x, int y,
| int z)
|
| GetValueIndexForExtent(...)
| GetValueIndexForExtent(self, array:vtkDataArray, extent:[int, int,
| int, int, int, int]) -> int
| C++: vtkIdType GetValueIndexForExtent(vtkDataArray *array,
| int extent[6])
|
| Given a data array and a coordinate, return the index of the
| value in the array corresponding to that coordinate, considering
| the number of components.
|
| HasAnyBlankCells(...)
| HasAnyBlankCells(self) -> bool
| C++: bool HasAnyBlankCells() override;
|
| Returns 1 if there are any blanking cells 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyBlankPoints(...)
| HasAnyBlankPoints(self) -> bool
| C++: bool HasAnyBlankPoints() override;
|
| Returns 1 if there are any blanking points 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasNumberOfScalarComponents(...)
| HasNumberOfScalarComponents(meta_data:vtkInformation) -> bool
| C++: static bool HasNumberOfScalarComponents(
| vtkInformation *meta_data)
|
| HasScalarType(...)
| HasScalarType(meta_data:vtkInformation) -> bool
| C++: static bool HasScalarType(vtkInformation *meta_data)
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Restore data object to initial state. THIS METHOD IS NOT THREAD
| SAFE.
|
| IsCellVisible(...)
| IsCellVisible(self, cellId:int) -> int
| C++: unsigned char IsCellVisible(vtkIdType cellId)
|
| Return non-zero value if specified point is visible. These
| methods should be called only after the dimensions of the grid
| are set.
|
| IsPointVisible(...)
| IsPointVisible(self, ptId:int) -> int
| C++: unsigned char IsPointVisible(vtkIdType ptId)
|
| Return non-zero value if specified point is visible. These
| methods should be called only after the dimensions of the grid
| are set.
|
| SetDimensions(...)
| SetDimensions(self, i:int, j:int, k:int) -> None
| C++: void SetDimensions(int i, int j, int k)
| SetDimensions(self, dim:(int, int, int)) -> None
| C++: void SetDimensions(const int dim[3])
|
| Set dimensions of rectilinear grid dataset. This also sets the
| extent.
|
| SetExtent(...)
| SetExtent(self, extent:[int, int, int, int, int, int]) -> None
| C++: void SetExtent(int extent[6])
| SetExtent(self, xMin:int, xMax:int, yMin:int, yMax:int, zMin:int,
| zMax:int) -> None
| C++: void SetExtent(int xMin, int xMax, int yMin, int yMax,
| int zMin, int zMax)
|
| Set/Get the extent. On each axis, the extent is defined by the
| index of the first point and the index of the last point. The
| extent should be set before the "Scalars" are set or allocated.
| The Extent is stored in the order (X, Y, Z). The dataset extent
| does not have to start at (0,0,0). (0,0,0) is just the extent of
| the origin. The first point (the one with Id=0) is at extent
| (Extent[0],Extent[2],Extent[4]). As for any dataset, a data array
| on point data starts at Id=0.
|
| SetNumberOfScalarComponents(...)
| SetNumberOfScalarComponents(n:int, meta_data:vtkInformation)
| -> None
| C++: static void SetNumberOfScalarComponents(int n,
| vtkInformation *meta_data)
|
| Set/Get the number of scalar components for points. As with the
| SetScalarType method this is setting pipeline info. 1 if not set
| or empty.
|
| SetScalarType(...)
| SetScalarType(__a:int, meta_data:vtkInformation) -> None
| C++: static void SetScalarType(int, vtkInformation *meta_data)
|
| Set/Get the scalar data type for the points. This is setting
| pipeline info. Assume VTK_DOUBLE if not set or empty.
|
| UnBlankCell(...)
| UnBlankCell(self, ptId:int) -> None
| C++: virtual void UnBlankCell(vtkIdType ptId)
| UnBlankCell(self, i:int, j:int, k:int) -> None
| C++: virtual void UnBlankCell(int i, int j, int k)
|
| UnBlankPoint(...)
| UnBlankPoint(self, ptId:int) -> None
| C++: virtual void UnBlankPoint(vtkIdType ptId)
| UnBlankPoint(self, i:int, j:int, k:int) -> None
| C++: virtual void UnBlankPoint(int i, int j, int k)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkCartesianGrid:
|
| cell_types
| read-only, calls GetCellTypes
|
| cell_types_array
| read-only, calls GetCellTypesArray
|
| cells
| read-only, calls GetCells
|
| data_description
| read-only, calls GetDataDescription
|
| data_dimension
| read-only, calls GetDataDimension
|
| extent_type
| read-only, calls GetExtentType
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| max_spatial_dimension
| read-only, calls GetMaxSpatialDimension
|
| min_spatial_dimension
| read-only, calls GetMinSpatialDimension
|
| number_of_scalar_components
| read-only, calls GetNumberOfScalarComponents
|
| scalar_type
| read-only, calls GetScalarType
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| AllocateCellGhostArray(...)
| AllocateCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocateCellGhostArray()
|
| Allocate ghost array for cells.
|
| AllocatePointGhostArray(...)
| AllocatePointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocatePointGhostArray()
|
| Allocate ghost array for points.
|
| CheckAttributes(...)
| CheckAttributes(self) -> int
| C++: int CheckAttributes()
|
| This method checks to see if the cell and point attributes match
| the geometry. Many filters will crash if the number of tuples in
| an array is less than the number of points/cells. This method
| returns 1 if there is a mismatch, and 0 if everything is ok. It
| prints an error if an array is too short, and a warning if an
| array is too long.
|
| CopyAttributes(...)
| CopyAttributes(self, ds:vtkDataSet) -> None
| C++: virtual void CopyAttributes(vtkDataSet *ds)
|
| Copy the attributes associated with the specified dataset to this
| instance of vtkDataSet. THIS METHOD IS NOT THREAD SAFE.
|
| GenerateGhostArray(...)
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int])
| -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6])
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int],
| cellOnly:bool) -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6],
| bool cellOnly)
|
| Normally called by pipeline executives or algorithms only. This
| method computes the ghost arrays for a given dataset. The zeroExt
| argument specifies the extent of the region which ghost type = 0.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return a pointer to the geometry bounding box in the form
| (xmin,xmax, ymin,ymax, zmin,zmax). THIS METHOD IS NOT THREAD
| SAFE.
|
| GetCellData(...)
| GetCellData(self) -> vtkCellData
| C++: vtkCellData *GetCellData()
|
| Return a pointer to this dataset's cell data. THIS METHOD IS
| THREAD SAFE
|
| GetCellGhostArray(...)
| GetCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellGhostArray()
|
| Get the array that defines the ghost type of each cell. We cache
| the pointer to the array to save a lookup involving string
| comparisons
|
| GetCellNumberOfFaces(...)
| GetCellNumberOfFaces(self, cellId:int, cellType:int,
| cell:vtkGenericCell) -> int
| C++: virtual int GetCellNumberOfFaces(vtkIdType cellId,
| unsigned char &cellType, vtkGenericCell *cell)
|
| Get the number of faces of a cell.
|
| Most of the times extracting the number of faces requires only
| extracting the cell type. However, for some cell types, the
| number of faces is not constant. For example, a convex point set
| cell can have a different number of faces for each cell. That's
| why this method requires the cell id and the dataset.
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: double *GetCenter()
| GetCenter(self, center:[float, float, float]) -> None
| C++: void GetCenter(double center[3])
|
| Get the center of the bounding box. THIS METHOD IS NOT THREAD
| SAFE.
|
| GetDistinctCellTypes(...)
| GetDistinctCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetDistinctCellTypes(vtkCellTypes *types)
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset 5 triangles, 3 lines, and
| 100 hexahedra would result a list of three entries, corresponding
| to the types VTK_TRIANGLE, VTK_LINE, and VTK_HEXAHEDRON. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetGhostArray(int type) override;
|
| Returns the ghost array for the given type (point or cell). Takes
| advantage of the cache with the pointer to the array to save a
| string comparison.
|
| GetLength(...)
| GetLength(self) -> float
| C++: double GetLength()
|
| Return the length of the diagonal of the bounding box. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Return the squared length of the diagonal of the bounding box.
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Datasets are composite objects and need to check each part for
| MTime THIS METHOD IS THREAD SAFE
|
| GetMeshMTime(...)
| GetMeshMTime(self) -> int
| C++: virtual vtkMTimeType GetMeshMTime()
|
| Abstract method which return the mesh (geometry/topology)
| modification time. This time is different from the usual MTime
| which also takes into account the modification of data arrays.
| This function can be used to track the changes on the mesh
| separately from the data arrays (eg. static mesh over time with
| transient data). The default implementation returns the MTime. It
| is up to subclasses to provide a better approach.
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| GetPointData(...)
| GetPointData(self) -> vtkPointData
| C++: vtkPointData *GetPointData()
|
| Return a pointer to this dataset's point data. THIS METHOD IS
| THREAD SAFE
|
| GetPointGhostArray(...)
| GetPointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetPointGhostArray()
|
| Gets the array that defines the ghost type of each point. We
| cache the pointer to the array to save a lookup involving string
| comparisons
|
| GetScalarRange(...)
| GetScalarRange(self, range:[float, float]) -> None
| C++: virtual void GetScalarRange(double range[2])
| GetScalarRange(self) -> (float, float)
| C++: double *GetScalarRange()
|
| Convenience method to get the range of the first component (and
| only the first component) of any scalars in the data set. If the
| data has both point data and cell data, it returns the (min/max)
| range of combined point and cell data. If there are no point or
| cell scalars the method will return (0,1). Note: It might be
| necessary to call Update to create or refresh the scalars before
| calling this method. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| HasAnyGhostCells(...)
| HasAnyGhostCells(self) -> bool
| C++: bool HasAnyGhostCells()
|
| Returns 1 if there are any ghost cells 0 otherwise.
|
| HasAnyGhostPoints(...)
| HasAnyGhostPoints(self) -> bool
| C++: bool HasAnyGhostPoints()
|
| Returns 1 if there are any ghost points 0 otherwise.
|
| NewCellIterator(...)
| NewCellIterator(self) -> vtkCellIterator
| C++: virtual vtkCellIterator *NewCellIterator()
|
| Return an iterator that traverses the cells in this data set.
|
| SetCellOrderAndRationalWeights(...)
| SetCellOrderAndRationalWeights(self, cellId:int,
| cell:vtkGenericCell) -> None
| C++: void SetCellOrderAndRationalWeights(vtkIdType cellId,
| vtkGenericCell *cell)
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: virtual void Squeeze()
|
| Reclaim any extra memory used to store data. THIS METHOD IS NOT
| THREAD SAFE.
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| cell_ghost_array
| read-only, calls GetCellGhostArray
|
| length2
| read-only, calls GetLength2
|
| m_time
| read-only, calls GetMTime
|
| mesh_m_time
| read-only, calls GetMeshMTime
|
| point_ghost_array
| read-only, calls GetPointGhostArray
|
| scalar_range
| read-only, calls GetScalarRange
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| CELL_DATA_FIELD = 2
|
| DATA_OBJECT_FIELD = 0
|
| FieldDataType = <class 'vtkmodules.vtkCommonDataModel.vtkDataSet.Field...
|
| POINT_DATA_FIELD = 1
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class RectilinearGrid(Grid, pyvista.core.filters.rectilinear_grid.RectilinearGridFilters, vtkmodules.vtkCommonDataModel.vtkRectilinearGrid)
| RectilinearGrid(*args, **kwargs) -> '_T'
|
| Dataset with variable spacing in the three coordinate directions.
|
| Can be initialized in several ways:
|
| * Create empty grid
| * Initialize from a :vtk:`vtkRectilinearGrid` object
| * Initialize directly from the point arrays
|
| Parameters
| ----------
| uinput : str, pathlib.Path, :vtk:`vtkRectilinearGrid`, numpy.ndarray, optional
| Filename, dataset, or array to initialize the rectilinear grid from. If a
| filename is passed, pyvista will attempt to load it as a
| :class:`RectilinearGrid`. If passed a :vtk:`vtkRectilinearGrid`, it
| will be wrapped. If a :class:`numpy.ndarray` is passed, this will be
| loaded as the x range.
|
| y : numpy.ndarray, optional
| Coordinates of the points in y direction. If this is passed, ``uinput``
| must be a :class:`numpy.ndarray`.
|
| z : numpy.ndarray, optional
| Coordinates of the points in z direction. If this is passed, ``uinput``
| and ``y`` must be a :class:`numpy.ndarray`.
|
| check_duplicates : bool, optional
| Check for duplications in any arrays that are passed. Defaults to
| ``False``. If ``True``, an error is raised if there are any duplicate
| values in any of the array-valued input arguments.
|
| deep : bool, optional
| Whether to deep copy a :vtk:`vtkRectilinearGrid` object.
| Default is ``False``. Keyword only.
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import vtk
| >>> import numpy as np
|
| Create an empty grid.
|
| >>> grid = pv.RectilinearGrid()
|
| Initialize from a :vtk:`vtkRectilinearGrid` object
|
| >>> vtkgrid = vtk.vtkRectilinearGrid()
| >>> grid = pv.RectilinearGrid(vtkgrid)
|
| Create from NumPy arrays.
|
| >>> xrng = np.arange(-10, 10, 2)
| >>> yrng = np.arange(-10, 10, 5)
| >>> zrng = np.arange(-10, 10, 1)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> grid.plot(show_edges=True)
|
| Method resolution order:
| RectilinearGrid
| Grid
| pyvista.core.dataset.DataSet
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| pyvista.core.filters.rectilinear_grid.RectilinearGridFilters
| vtkmodules.vtkCommonDataModel.vtkRectilinearGrid
| vtkmodules.vtkCommonDataModel.vtkCartesianGrid
| vtkmodules.vtkCommonDataModel.vtkDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self: 'Self', *args, check_duplicates: 'bool' = False, deep: 'bool' = False, validate: 'bool | _NestedMeshValidationFields' = False, **kwargs) -> 'None'
| Initialize the rectilinear grid.
|
| __repr__(self: 'Self') -> 'str'
| Return the default representation.
|
| __str__(self: 'Self') -> 'str'
| Return the str representation.
|
| cast_to_structured_grid(self: 'Self') -> 'StructuredGrid'
| Cast this rectilinear grid to a :class:`~pyvista.StructuredGrid`.
|
| .. note::
|
| Casting converts :class:`~pyvista.CellType.PIXEL` cells to
| :class:`~pyvista.CellType.QUAD` cells for 2D inputs, and
| :class:`~pyvista.CellType.VOXEL` cells to :class:`~pyvista.CellType.HEXAHEDRON` cells
| for 3D inputs. To preserve cell type, use
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` instead.
|
| Returns
| -------
| pyvista.StructuredGrid
| This grid as a structured grid.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| meshgrid
| Return a meshgrid of numpy arrays for this mesh.
|
| This simply returns a :func:`numpy.meshgrid` of the
| coordinates for this mesh in ``ij`` indexing. These are a copy
| of the points of this mesh.
|
| Returns
| -------
| tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]
| Tuple of numpy arrays representing the points of this mesh.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| dimensions
| Return the grid's dimensions.
|
| These are effectively the number of points along each of the
| three dataset axes.
|
| Returns
| -------
| tuple[int]
| Dimensions of the grid.
|
| Examples
| --------
| Create a uniform grid with dimensions ``(1, 2, 3)``.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(2, 3, 4))
| >>> grid.dimensions
| (2, 3, 4)
| >>> grid.plot(show_edges=True)
|
| Set the dimensions to ``(3, 4, 5)``
|
| >>> grid.dimensions = (3, 4, 5)
| >>> grid.plot(show_edges=True)
|
| points
| Return a copy of the points as an ``(n, 3)`` numpy array.
|
| Returns
| -------
| numpy.ndarray
| Array of points.
|
| Notes
| -----
| Points of a :class:`pyvista.RectilinearGrid` cannot be
| set. Set point coordinates with :attr:`RectilinearGrid.x`,
| :attr:`RectilinearGrid.y`, or :attr:`RectilinearGrid.z`.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.arange(-10, 10, 10, dtype=float)
| >>> yrng = np.arange(-10, 10, 10, dtype=float)
| >>> zrng = np.arange(-10, 10, 10, dtype=float)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> grid.points
| array([[-10., -10., -10.],
| [ 0., -10., -10.],
| [-10., 0., -10.],
| [ 0., 0., -10.],
| [-10., -10., 0.],
| [ 0., -10., 0.],
| [-10., 0., 0.],
| [ 0., 0., 0.]])
|
| x
| Return or set the coordinates along the X-direction.
|
| Returns
| -------
| numpy.ndarray
| Array of points along the X-direction.
|
| Examples
| --------
| Return the x coordinates of a RectilinearGrid.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.arange(-10, 10, 10, dtype=float)
| >>> yrng = np.arange(-10, 10, 10, dtype=float)
| >>> zrng = np.arange(-10, 10, 10, dtype=float)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> grid.x
| array([-10., 0.])
|
| Set the x coordinates of a RectilinearGrid.
|
| >>> grid.x = [-10.0, 0.0, 10.0]
| >>> grid.x
| array([-10., 0., 10.])
|
| y
| Return or set the coordinates along the Y-direction.
|
| Returns
| -------
| numpy.ndarray
| Array of points along the Y-direction.
|
| Examples
| --------
| Return the y coordinates of a RectilinearGrid.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.arange(-10, 10, 10, dtype=float)
| >>> yrng = np.arange(-10, 10, 10, dtype=float)
| >>> zrng = np.arange(-10, 10, 10, dtype=float)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> grid.y
| array([-10., 0.])
|
| Set the y coordinates of a RectilinearGrid.
|
| >>> grid.y = [-10.0, 0.0, 10.0]
| >>> grid.y
| array([-10., 0., 10.])
|
| z
| Return or set the coordinates along the Z-direction.
|
| Returns
| -------
| numpy.ndarray
| Array of points along the Z-direction.
|
| Examples
| --------
| Return the z coordinates of a RectilinearGrid.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.arange(-10, 10, 10, dtype=float)
| >>> yrng = np.arange(-10, 10, 10, dtype=float)
| >>> zrng = np.arange(-10, 10, 10, dtype=float)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> grid.z
| array([-10., 0.])
|
| Set the z coordinates of a RectilinearGrid.
|
| >>> grid.z = [-10.0, 0.0, 10.0]
| >>> grid.z
| array([-10., 0., 10.])
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| ----------------------------------------------------------------------
| Methods inherited from Grid:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| to_hexahedra(self: 'Self') -> 'UnstructuredGrid'
| Convert voxels to hexahedra.
|
| Convert this mesh to :class:`~pyvista.UnstructuredGrid` with
| :attr:`~pyvista.CellType.HEXAHEDRON` cells. Equivalent to
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` except the output has
| hexahedra instead of :attr:`~pyvista.CellType.VOXEL` cells.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with :attr:`~pyvista.CellType.HEXAHEDRON` cells.
|
| Raises
| ------
| ValueError
| If the input is not 3-dimensional.
|
| See Also
| --------
| to_quads, to_tetrahedra
| pyvista.DataSet.cast_to_unstructured_grid
|
| Examples
| --------
| Convert a 3D :class:`~pyvista.ImageData` to hexahedra.
|
| >>> import pyvista as pv
| >>> image = pv.ImageData(dimensions=(2, 2, 2))
| >>> hexes = image.to_hexahedra()
| >>> hexes.distinct_cell_types == {pv.CellType.HEXAHEDRON}
| True
|
| to_quads(self: 'Self') -> 'UnstructuredGrid'
| Convert pixels to quads.
|
| Convert this mesh to :class:`~pyvista.UnstructuredGrid` with
| :attr:`~pyvista.CellType.QUAD` cells. Equivalent to
| :meth:`~pyvista.DataSet.cast_to_unstructured_grid` except the output has
| quads instead of :attr:`~pyvista.CellType.PIXEL` cells.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with :attr:`~pyvista.CellType.QUAD` cells.
|
| Raises
| ------
| ValueError
| If the input is not 2-dimensional.
|
| See Also
| --------
| to_hexahedra, to_tetrahedra
| pyvista.DataSet.cast_to_unstructured_grid
|
| Examples
| --------
| Convert a 2D :class:`~pyvista.ImageData` to quads.
|
| >>> import pyvista as pv
| >>> image = pv.ImageData(dimensions=(3, 2, 1))
| >>> quads = image.to_quads()
| >>> quads.distinct_cell_types == {pv.CellType.QUAD}
| True
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| translate(self: '_MeshType_co', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Translate the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Translated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.translate
| Concatenate a translation matrix with a transformation.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=False)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.rectilinear_grid.RectilinearGridFilters:
|
| to_tetrahedra(self, tetra_per_cell: 'int' = 5, mixed: 'str | Sequence[int] | bool' = False, pass_cell_ids: 'bool' = True, pass_data: 'bool' = True, progress_bar: 'bool' = False)
| Create a tetrahedral mesh structured grid.
|
| Parameters
| ----------
| tetra_per_cell : int, default: 5
| The number of tetrahedrons to divide each cell into. Can be
| either ``5``, ``6``, or ``12``. If ``mixed=True``, this value is
| overridden.
|
| mixed : str, bool, sequence, default: False
| When set, subdivides some cells into 5 and some cells into 12. Set
| to ``True`` to use the active cell scalars of the
| :class:`pyvista.RectilinearGrid` to be either 5 or 12 to
| determining the number of tetrahedra to generate per cell.
|
| When a sequence, uses these values to subdivide the cells. When a
| string uses a cell array rather than the active array to determine
| the number of tetrahedra to generate per cell.
|
| pass_cell_ids : bool, default: True
| Set to ``True`` to make the tetrahedra have scalar data indicating
| which cell they came from in the original
| :class:`pyvista.RectilinearGrid`. The name of this array is
| ``'vtkOriginalCellIds'`` within the ``cell_data``.
|
| pass_data : bool, default: True
| Set to ``True`` to make the tetrahedra mesh have the cell data from
| the original :class:`pyvista.RectilinearGrid`. This uses
| ``pass_cell_ids=True`` internally. If ``True``, ``pass_cell_ids``
| will also be set to ``True``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the tetrahedral cells.
|
| Examples
| --------
| Divide a rectangular grid into tetrahedrons. Each cell contains by
| default 5 tetrahedrons.
|
| First, create and plot the grid.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 2)
| >>> yrng = np.linspace(0, 1, 2)
| >>> zrng = np.linspace(0, 2, 3)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> grid.plot()
|
| Now, generate the tetrahedra plot in the exploded view of the cell.
|
| >>> tet_grid = grid.to_tetrahedra()
| >>> tet_grid.explode(factor=0.5).plot(show_edges=True)
|
| Take the same grid but divide the first cell into 5 cells and the other
| cell into 12 tetrahedrons per cell.
|
| >>> tet_grid = grid.to_tetrahedra(mixed=[5, 12])
| >>> tet_grid.explode(factor=0.5).plot(show_edges=True)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkRectilinearGrid:
|
| ComputeBounds(...)
| ComputeBounds(self) -> None
| C++: void ComputeBounds() override;
|
| Compute the data bounding box from data points. THIS METHOD IS
| NOT THREAD SAFE.
|
| ComputeCellId(...)
| ComputeCellId(self, ijk:[int, int, int]) -> int
| C++: vtkIdType ComputeCellId(int ijk[3]) override;
|
| Given a location in structured coordinates (i-j-k), return the
| cell id. Rely on vtkStructuredData::ComputeCellId Unifying this
| behavior with vtkImageData could be considered.
|
| ComputePointId(...)
| ComputePointId(self, ijk:[int, int, int]) -> int
| C++: vtkIdType ComputePointId(int ijk[3]) override;
|
| Given a location in structured coordinates (i-j-k), return the
| point id. Rely on vtkStructuredData::ComputePointId Unifying this
| behavior with vtkImageData could be considered.
|
| ComputeStructuredCoordinates(...)
| ComputeStructuredCoordinates(self, x:(float, float, float),
| ijk:[int, int, int], pcoords:[float, float, float]) -> int
| C++: int ComputeStructuredCoordinates(const double x[3],
| int ijk[3], double pcoords[3]) override;
| ComputeStructuredCoordinates(self, x:[float, float, float],
| ijk:[int, int, int], pcoords:[float, float, float]) -> int
| C++: int ComputeStructuredCoordinates(double x[3], int ijk[3],
| double pcoords[3])
|
| Computes the structured coordinates for a point x[3]. The cell is
| specified by the array ijk[3], and the parametric coordinates in
| the cell are specified with pcoords[3]. The function returns a 0
| if the point x is outside of the grid, and a 1 if inside the
| grid.
|
| CopyStructure(...)
| CopyStructure(self, ds:vtkDataSet) -> None
| C++: void CopyStructure(vtkDataSet *ds) override;
|
| Copy the geometric and topological structure of an input
| rectilinear grid object.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: void Crop(const int *updateExtent) override;
|
| Reallocates and copies to set the Extent to the UpdateExtent.
| This is used internally when the exact extent is requested, and
| the source generated more than the update extent.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| ExtendedNew(...)
| ExtendedNew() -> vtkRectilinearGrid
| C++: static vtkRectilinearGrid *ExtendedNew()
|
| FindCell(...)
| FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int,
| tol2:float, subId:int, pcoords:[float, float, float],
| weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
| FindCell(self, x:[float, float, float], cell:vtkCell,
| gencell:vtkGenericCell, cellId:int, tol2:float, subId:int,
| pcoords:[float, float, float], weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkGenericCell *gencell, vtkIdType cellId, double tol2,
| int &subId, double pcoords[3], double *weights) override;
|
| Locate cell based on global coordinate x and tolerance squared.
| If cell and cellId is non-nullptr, then search starts from this
| cell and looks at immediate neighbors. Returns cellId >= 0 if
| inside, < 0 otherwise. The parametric coordinates are provided
| in pcoords[3]. The interpolation weights are returned in
| weights[]. (The number of weights is equal to the number of
| points in the found cell). Tolerance is used to control how close
| the point is to be considered "in" the cell. THIS METHOD IS NOT
| THREAD SAFE.
|
| FindPoint(...)
| FindPoint(self, x:[float, float, float]) -> int
| C++: vtkIdType FindPoint(double x[3]) override;
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated. The
| memory size returned is guaranteed to be greater than or equal to
| the memory required to represent the data (e.g., extra space in
| arrays, etc. are not included in the return value). THIS METHOD
| IS THREAD SAFE.
|
| GetCell(...)
| GetCell(self, cellId:int, cell:vtkGenericCell) -> None
| C++: void GetCell(vtkIdType cellId, vtkGenericCell *cell)
| override;
| GetCell(self, cellId:int) -> vtkCell
| C++: vtkCell *GetCell(vtkIdType cellId) override;
| GetCell(self, i:int, j:int, k:int) -> vtkCell
| C++: vtkCell *GetCell(int i, int j, int k) override;
|
| Standard vtkDataSet API methods. See vtkCartesianGrid for more
| information.
|
| GetCellBounds(...)
| GetCellBounds(self, cellId:int, bounds:[float, float, float,
| float, float, float]) -> None
| C++: void GetCellBounds(vtkIdType cellId, double bounds[6])
| override;
|
| Get the bounds of the cell with cellId such that: 0 <= cellId <
| NumberOfCells. A subclass may be able to determine the bounds of
| cell without using an expensive GetCell() method. A default
| implementation is provided that actually uses a GetCell() call.
| This is to ensure the method is available to all datasets.
| Subclasses should override this method to provide an efficient
| implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkRectilinearGrid
| C++: static vtkRectilinearGrid *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkRectilinearGrid
| C++: static vtkRectilinearGrid *GetData(vtkInformationVector *v,
| int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return what type of dataset this is.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetPoint(...)
| GetPoint(self, i:int, j:int, k:int, p:[float, float, float])
| -> None
| C++: void GetPoint(int i, int j, int k, double p[3])
| GetPoint(self, id:int, x:[float, float, float]) -> None
| C++: void GetPoint(vtkIdType id, double x[3]) override;
| GetPoint(self, ptId:int) -> (float, float, float)
| C++: double *GetPoint(vtkIdType ptId) override;
|
| Given the IJK-coordinates of the point, it returns the
| corresponding xyz-coordinates. The xyz coordinates are stored in
| the user-supplied array p.
|
| GetXCoordinates(...)
| GetXCoordinates(self) -> vtkDataArray
| C++: virtual vtkDataArray *GetXCoordinates()
|
| GetYCoordinates(...)
| GetYCoordinates(self) -> vtkDataArray
| C++: virtual vtkDataArray *GetYCoordinates()
|
| GetZCoordinates(...)
| GetZCoordinates(self) -> vtkDataArray
| C++: virtual vtkDataArray *GetZCoordinates()
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Restore object to initial state. Release memory back to system.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkRectilinearGrid
| C++: vtkRectilinearGrid *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkRectilinearGrid
| C++: static vtkRectilinearGrid *SafeDownCast(vtkObjectBase *o)
|
| SetXCoordinates(...)
| SetXCoordinates(self, __a:vtkDataArray) -> None
| C++: virtual void SetXCoordinates(vtkDataArray *)
|
| Specify the grid coordinates in the x-direction.
|
| SetYCoordinates(...)
| SetYCoordinates(self, __a:vtkDataArray) -> None
| C++: virtual void SetYCoordinates(vtkDataArray *)
|
| Specify the grid coordinates in the y-direction.
|
| SetZCoordinates(...)
| SetZCoordinates(self, __a:vtkDataArray) -> None
| C++: virtual void SetZCoordinates(vtkDataArray *)
|
| Specify the grid coordinates in the z-direction.
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkRectilinearGrid:
|
| __this__
| Pointer to the C++ object.
|
| data_object_type
| read-only, calls GetDataObjectType
|
| x_coordinates
| read-write, calls GetXCoordinates/SetXCoordinates
|
| y_coordinates
| read-write, calls GetYCoordinates/SetYCoordinates
|
| z_coordinates
| read-write, calls GetZCoordinates/SetZCoordinates
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkRectilinearGrid:
|
| __vtkname__ = 'vtkRectilinearGrid'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkCartesianGrid:
|
| BlankCell(...)
| BlankCell(self, ptId:int) -> None
| C++: virtual void BlankCell(vtkIdType ptId)
| BlankCell(self, i:int, j:int, k:int) -> None
| C++: virtual void BlankCell(int i, int j, int k)
|
| Methods for supporting blanking of cells. Blanking turns on or
| off cells in the structured grid. These methods should be called
| only after the dimensions of the grid are set.
|
| BlankPoint(...)
| BlankPoint(self, ptId:int) -> None
| C++: virtual void BlankPoint(vtkIdType ptId)
| BlankPoint(self, i:int, j:int, k:int) -> None
| C++: virtual void BlankPoint(int i, int j, int k)
|
| Methods for supporting blanking of cells. Blanking turns on or
| off points in the structured grid, and hence the cells connected
| to them. These methods should be called only after the dimensions
| of the grid are set.
|
| FindAndGetCell(...)
| FindAndGetCell(self, x:[float, float, float], cell:vtkCell,
| cellId:int, tol2:float, subId:int, pcoords:[float, float,
| float], weights:[float, ...]) -> vtkCell
| C++: vtkCell *FindAndGetCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
|
| Locate the cell that contains a point and return the cell. Also
| returns the subcell id, parametric coordinates and weights for
| subsequent interpolation. This method combines the derived class
| methods int FindCell and vtkCell *GetCell. Derived classes may
| provide a more efficient implementation. See for example
| vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE.
|
| GetCellDims(...)
| GetCellDims(self, cellDims:[int, int, int]) -> None
| C++: void GetCellDims(int cellDims[3])
|
| Given the node dimensions of this grid instance, this method
| computes the node dimensions. The value in each dimension can
| will have a lowest value of "1" such that computing the total
| number of cells can be achieved by simply by
| cellDims[0]*cellDims[1]*cellDims[2].
|
| GetCellNeighbors(...)
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds) override;
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList, seedLoc:[int, ...]) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds, int *seedLoc)
|
| Topological inquiry to get all cells using list of points
| exclusive of cell specified (e.g., cellId). Note that the list
| consists of only cells that use ALL the points provided. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetCellPoints(...)
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...),
| ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts, vtkIdList *ptIds) override;
| GetCellPoints(self, cellId:int, ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
| override;
|
| Topological inquiry to get points defining cell.
|
| This function MAY use ptIds, which is an object that is created
| by each thread, to guarantee thread safety.
|
| @warning Subsequent calls to this method may invalidate previous
| call
| results.
|
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetCellSize(...)
| GetCellSize(self, cellId:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType cellId) override;
|
| Get the size of cell with cellId such that: 0 <= cellId <
| NumberOfCells. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| @warning This method MUST be overridden for performance reasons.
| Default implementation is very inefficient.
|
| GetCellType(...)
| GetCellType(self, cellId:int) -> int
| C++: int GetCellType(vtkIdType cellId) override;
|
| Get type of cell with cellId such that: 0 <= cellId <
| NumberOfCells. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetCellTypes(...)
| GetCellTypes(self) -> vtkConstantArray_IhE
| C++: vtkConstantArray<unsigned char> *GetCellTypes()
| GetCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetCellTypes(vtkCellTypes *types)
|
| GetCellTypesArray(...)
| GetCellTypesArray(self) -> vtkConstantArray_IiE
| C++: vtkConstantArray<int> *GetCellTypesArray()
|
| GetCells(...)
| GetCells(self) -> vtkStructuredCellArray
| C++: vtkStructuredCellArray *GetCells()
|
| Return the image data connectivity array.
|
| NOTE: the returned object should not be modified.
|
| GetDataDescription(...)
| GetDataDescription(self) -> int
| C++: virtual int GetDataDescription()
|
| Get the data description of the rectilinear grid.
|
| GetDataDimension(...)
| GetDataDimension(self) -> int
| C++: int GetDataDimension()
|
| Return the dimensionality of the data.
|
| GetDimensions(...)
| GetDimensions(self) -> (int, int, int)
| C++: int *GetDimensions()
| GetDimensions(self, dims:[int, int, int]) -> None
| C++: void GetDimensions(int dims[3])
| GetDimensions(self, dims:[int, int, int]) -> None
| C++: void GetDimensions(vtkIdType dims[3])
|
| Get dimensions of this structured points dataset. It is the
| number of points on each axis. Dimensions are computed from
| Extents during this call.
| \warning Non thread-safe, use second signature if you want it to
| be.
|
| GetExtent(...)
| GetExtent(self) -> (int, int, int, int, int, int)
| C++: virtual int *GetExtent()
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: int GetExtentType() override;
|
| Structured extent. The extent type is a 3D extent
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Convenience method returns largest cell size in dataset. This is
| generally used to allocate memory for supporting data structures.
| THIS METHOD IS THREAD SAFE
|
| GetMaxSpatialDimension(...)
| GetMaxSpatialDimension(self) -> int
| C++: int GetMaxSpatialDimension() override;
|
| Get the maximum/minimum spatial dimensionality of the data which
| is the maximum/minimum dimension of all cells.
|
| @warning This method MUST be overridden for performance reasons.
| Default implementation is very inefficient.
|
| GetMinSpatialDimension(...)
| GetMinSpatialDimension(self) -> int
| C++: int GetMinSpatialDimension() override;
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| Determine the number of cells composing the dataset. THIS METHOD
| IS THREAD SAFE
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| Determine the number of points composing the dataset. THIS METHOD
| IS THREAD SAFE
|
| GetNumberOfScalarComponents(...)
| GetNumberOfScalarComponents(meta_data:vtkInformation) -> int
| C++: static int GetNumberOfScalarComponents(
| vtkInformation *meta_data)
| GetNumberOfScalarComponents(self) -> int
| C++: int GetNumberOfScalarComponents()
|
| GetPointCells(...)
| GetPointCells(self, ptId:int, cellIds:vtkIdList) -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
| override;
|
| Topological inquiry to get cells using point. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints() override;
|
| Standard vtkDataSet API methods. See vtkDataSet for more
| information.
|
| GetScalarType(...)
| GetScalarType(meta_data:vtkInformation) -> int
| C++: static int GetScalarType(vtkInformation *meta_data)
| GetScalarType(self) -> int
| C++: int GetScalarType()
|
| GetScalarTypeAsString(...)
| GetScalarTypeAsString(self) -> str
| C++: const char *GetScalarTypeAsString()
|
| GetTupleIndex(...)
| GetTupleIndex(self, array:vtkDataArray, coordinates:[int, int,
| int]) -> int
| C++: vtkIdType GetTupleIndex(vtkDataArray *array,
| int coordinates[3])
| GetTupleIndex(self, array:vtkDataArray, x:int, y:int, z:int)
| -> int
| C++: vtkIdType GetTupleIndex(vtkDataArray *array, int x, int y,
| int z)
|
| GetTupleIndexForExtent(...)
| GetTupleIndexForExtent(self, array:vtkDataArray, extent:[int, int,
| int, int, int, int]) -> int
| C++: vtkIdType GetTupleIndexForExtent(vtkDataArray *array,
| int extent[6])
|
| Given a data array and a coordinate, return the index of the
| tuple in the array corresponding to that coordinate.
|
| GetValueIndex(...)
| GetValueIndex(self, array:vtkDataArray, coordinates:[int, int,
| int]) -> int
| C++: vtkIdType GetValueIndex(vtkDataArray *array,
| int coordinates[3])
| GetValueIndex(self, array:vtkDataArray, x:int, y:int, z:int)
| -> int
| C++: vtkIdType GetValueIndex(vtkDataArray *array, int x, int y,
| int z)
|
| GetValueIndexForExtent(...)
| GetValueIndexForExtent(self, array:vtkDataArray, extent:[int, int,
| int, int, int, int]) -> int
| C++: vtkIdType GetValueIndexForExtent(vtkDataArray *array,
| int extent[6])
|
| Given a data array and a coordinate, return the index of the
| value in the array corresponding to that coordinate, considering
| the number of components.
|
| HasAnyBlankCells(...)
| HasAnyBlankCells(self) -> bool
| C++: bool HasAnyBlankCells() override;
|
| Returns 1 if there are any blanking cells 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyBlankPoints(...)
| HasAnyBlankPoints(self) -> bool
| C++: bool HasAnyBlankPoints() override;
|
| Returns 1 if there are any blanking points 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasNumberOfScalarComponents(...)
| HasNumberOfScalarComponents(meta_data:vtkInformation) -> bool
| C++: static bool HasNumberOfScalarComponents(
| vtkInformation *meta_data)
|
| HasScalarType(...)
| HasScalarType(meta_data:vtkInformation) -> bool
| C++: static bool HasScalarType(vtkInformation *meta_data)
|
| IsCellVisible(...)
| IsCellVisible(self, cellId:int) -> int
| C++: unsigned char IsCellVisible(vtkIdType cellId)
|
| Return non-zero value if specified point is visible. These
| methods should be called only after the dimensions of the grid
| are set.
|
| IsPointVisible(...)
| IsPointVisible(self, ptId:int) -> int
| C++: unsigned char IsPointVisible(vtkIdType ptId)
|
| Return non-zero value if specified point is visible. These
| methods should be called only after the dimensions of the grid
| are set.
|
| SetDimensions(...)
| SetDimensions(self, i:int, j:int, k:int) -> None
| C++: void SetDimensions(int i, int j, int k)
| SetDimensions(self, dim:(int, int, int)) -> None
| C++: void SetDimensions(const int dim[3])
|
| Set dimensions of rectilinear grid dataset. This also sets the
| extent.
|
| SetExtent(...)
| SetExtent(self, extent:[int, int, int, int, int, int]) -> None
| C++: void SetExtent(int extent[6])
| SetExtent(self, xMin:int, xMax:int, yMin:int, yMax:int, zMin:int,
| zMax:int) -> None
| C++: void SetExtent(int xMin, int xMax, int yMin, int yMax,
| int zMin, int zMax)
|
| Set/Get the extent. On each axis, the extent is defined by the
| index of the first point and the index of the last point. The
| extent should be set before the "Scalars" are set or allocated.
| The Extent is stored in the order (X, Y, Z). The dataset extent
| does not have to start at (0,0,0). (0,0,0) is just the extent of
| the origin. The first point (the one with Id=0) is at extent
| (Extent[0],Extent[2],Extent[4]). As for any dataset, a data array
| on point data starts at Id=0.
|
| SetNumberOfScalarComponents(...)
| SetNumberOfScalarComponents(n:int, meta_data:vtkInformation)
| -> None
| C++: static void SetNumberOfScalarComponents(int n,
| vtkInformation *meta_data)
|
| Set/Get the number of scalar components for points. As with the
| SetScalarType method this is setting pipeline info. 1 if not set
| or empty.
|
| SetScalarType(...)
| SetScalarType(__a:int, meta_data:vtkInformation) -> None
| C++: static void SetScalarType(int, vtkInformation *meta_data)
|
| Set/Get the scalar data type for the points. This is setting
| pipeline info. Assume VTK_DOUBLE if not set or empty.
|
| UnBlankCell(...)
| UnBlankCell(self, ptId:int) -> None
| C++: virtual void UnBlankCell(vtkIdType ptId)
| UnBlankCell(self, i:int, j:int, k:int) -> None
| C++: virtual void UnBlankCell(int i, int j, int k)
|
| UnBlankPoint(...)
| UnBlankPoint(self, ptId:int) -> None
| C++: virtual void UnBlankPoint(vtkIdType ptId)
| UnBlankPoint(self, i:int, j:int, k:int) -> None
| C++: virtual void UnBlankPoint(int i, int j, int k)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkCartesianGrid:
|
| cell_types
| read-only, calls GetCellTypes
|
| cell_types_array
| read-only, calls GetCellTypesArray
|
| cells
| read-only, calls GetCells
|
| data_description
| read-only, calls GetDataDescription
|
| data_dimension
| read-only, calls GetDataDimension
|
| extent
| read-write, calls GetExtent/SetExtent
|
| extent_type
| read-only, calls GetExtentType
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| max_spatial_dimension
| read-only, calls GetMaxSpatialDimension
|
| min_spatial_dimension
| read-only, calls GetMinSpatialDimension
|
| number_of_scalar_components
| read-only, calls GetNumberOfScalarComponents
|
| scalar_type
| read-only, calls GetScalarType
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| AllocateCellGhostArray(...)
| AllocateCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocateCellGhostArray()
|
| Allocate ghost array for cells.
|
| AllocatePointGhostArray(...)
| AllocatePointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocatePointGhostArray()
|
| Allocate ghost array for points.
|
| CheckAttributes(...)
| CheckAttributes(self) -> int
| C++: int CheckAttributes()
|
| This method checks to see if the cell and point attributes match
| the geometry. Many filters will crash if the number of tuples in
| an array is less than the number of points/cells. This method
| returns 1 if there is a mismatch, and 0 if everything is ok. It
| prints an error if an array is too short, and a warning if an
| array is too long.
|
| CopyAttributes(...)
| CopyAttributes(self, ds:vtkDataSet) -> None
| C++: virtual void CopyAttributes(vtkDataSet *ds)
|
| Copy the attributes associated with the specified dataset to this
| instance of vtkDataSet. THIS METHOD IS NOT THREAD SAFE.
|
| GenerateGhostArray(...)
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int])
| -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6])
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int],
| cellOnly:bool) -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6],
| bool cellOnly)
|
| Normally called by pipeline executives or algorithms only. This
| method computes the ghost arrays for a given dataset. The zeroExt
| argument specifies the extent of the region which ghost type = 0.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return a pointer to the geometry bounding box in the form
| (xmin,xmax, ymin,ymax, zmin,zmax). THIS METHOD IS NOT THREAD
| SAFE.
|
| GetCellData(...)
| GetCellData(self) -> vtkCellData
| C++: vtkCellData *GetCellData()
|
| Return a pointer to this dataset's cell data. THIS METHOD IS
| THREAD SAFE
|
| GetCellGhostArray(...)
| GetCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellGhostArray()
|
| Get the array that defines the ghost type of each cell. We cache
| the pointer to the array to save a lookup involving string
| comparisons
|
| GetCellNumberOfFaces(...)
| GetCellNumberOfFaces(self, cellId:int, cellType:int,
| cell:vtkGenericCell) -> int
| C++: virtual int GetCellNumberOfFaces(vtkIdType cellId,
| unsigned char &cellType, vtkGenericCell *cell)
|
| Get the number of faces of a cell.
|
| Most of the times extracting the number of faces requires only
| extracting the cell type. However, for some cell types, the
| number of faces is not constant. For example, a convex point set
| cell can have a different number of faces for each cell. That's
| why this method requires the cell id and the dataset.
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: double *GetCenter()
| GetCenter(self, center:[float, float, float]) -> None
| C++: void GetCenter(double center[3])
|
| Get the center of the bounding box. THIS METHOD IS NOT THREAD
| SAFE.
|
| GetDistinctCellTypes(...)
| GetDistinctCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetDistinctCellTypes(vtkCellTypes *types)
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset 5 triangles, 3 lines, and
| 100 hexahedra would result a list of three entries, corresponding
| to the types VTK_TRIANGLE, VTK_LINE, and VTK_HEXAHEDRON. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetGhostArray(int type) override;
|
| Returns the ghost array for the given type (point or cell). Takes
| advantage of the cache with the pointer to the array to save a
| string comparison.
|
| GetLength(...)
| GetLength(self) -> float
| C++: double GetLength()
|
| Return the length of the diagonal of the bounding box. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Return the squared length of the diagonal of the bounding box.
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Datasets are composite objects and need to check each part for
| MTime THIS METHOD IS THREAD SAFE
|
| GetMeshMTime(...)
| GetMeshMTime(self) -> int
| C++: virtual vtkMTimeType GetMeshMTime()
|
| Abstract method which return the mesh (geometry/topology)
| modification time. This time is different from the usual MTime
| which also takes into account the modification of data arrays.
| This function can be used to track the changes on the mesh
| separately from the data arrays (eg. static mesh over time with
| transient data). The default implementation returns the MTime. It
| is up to subclasses to provide a better approach.
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| GetPointData(...)
| GetPointData(self) -> vtkPointData
| C++: vtkPointData *GetPointData()
|
| Return a pointer to this dataset's point data. THIS METHOD IS
| THREAD SAFE
|
| GetPointGhostArray(...)
| GetPointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetPointGhostArray()
|
| Gets the array that defines the ghost type of each point. We
| cache the pointer to the array to save a lookup involving string
| comparisons
|
| GetScalarRange(...)
| GetScalarRange(self, range:[float, float]) -> None
| C++: virtual void GetScalarRange(double range[2])
| GetScalarRange(self) -> (float, float)
| C++: double *GetScalarRange()
|
| Convenience method to get the range of the first component (and
| only the first component) of any scalars in the data set. If the
| data has both point data and cell data, it returns the (min/max)
| range of combined point and cell data. If there are no point or
| cell scalars the method will return (0,1). Note: It might be
| necessary to call Update to create or refresh the scalars before
| calling this method. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| HasAnyGhostCells(...)
| HasAnyGhostCells(self) -> bool
| C++: bool HasAnyGhostCells()
|
| Returns 1 if there are any ghost cells 0 otherwise.
|
| HasAnyGhostPoints(...)
| HasAnyGhostPoints(self) -> bool
| C++: bool HasAnyGhostPoints()
|
| Returns 1 if there are any ghost points 0 otherwise.
|
| NewCellIterator(...)
| NewCellIterator(self) -> vtkCellIterator
| C++: virtual vtkCellIterator *NewCellIterator()
|
| Return an iterator that traverses the cells in this data set.
|
| SetCellOrderAndRationalWeights(...)
| SetCellOrderAndRationalWeights(self, cellId:int,
| cell:vtkGenericCell) -> None
| C++: void SetCellOrderAndRationalWeights(vtkIdType cellId,
| vtkGenericCell *cell)
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: virtual void Squeeze()
|
| Reclaim any extra memory used to store data. THIS METHOD IS NOT
| THREAD SAFE.
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| cell_ghost_array
| read-only, calls GetCellGhostArray
|
| length2
| read-only, calls GetLength2
|
| m_time
| read-only, calls GetMTime
|
| mesh_m_time
| read-only, calls GetMeshMTime
|
| point_ghost_array
| read-only, calls GetPointGhostArray
|
| scalar_range
| read-only, calls GetScalarRange
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| CELL_DATA_FIELD = 2
|
| DATA_OBJECT_FIELD = 0
|
| FieldDataType = <class 'vtkmodules.vtkCommonDataModel.vtkDataSet.Field...
|
| POINT_DATA_FIELD = 1
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
DATA
ClassVar = typing.ClassVar
Special type construct to mark class variables.
An annotation wrapped in ClassVar indicates that a given
attribute is intended to be used as a class variable and
should not be set on instances of that class.
Usage::
class Starship:
stats: ClassVar[dict[str, int]] = {} # class variable
damage: int = 10 # instance variable
ClassVar accepts only types and cannot be further subscribed.
Note that ClassVar is not a class itself, and should not
be used with isinstance() or issubclass().
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
TYPE_CHECKING = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\grid.py
pyvista.grid_from_sph_coords
Python Library Documentation: function grid_from_sph_coords in module pyvista.core.utilities.features
grid_from_sph_coords(theta, phi, r)
Create a structured grid from arrays of spherical coordinates.
Parameters
----------
theta : array_like[float]
Azimuthal angle in degrees ``[0, 360]``.
phi : array_like[float]
Polar (zenith) angle in degrees ``[0, 180]``.
r : array_like[float]
Distance (radius) from the point of origin.
Returns
-------
pyvista.StructuredGrid
Structured grid.
See Also
--------
:ref:`spherical_example`
pyvista.has_module
Python Library Documentation: _lru_cache_wrapper in module pyvista.core.utilities.misc
has_module(module_name: 'str') -> 'bool'
Return if a module can be imported.
Parameters
----------
module_name : str
Name of the module to check.
Returns
-------
bool
``True`` if the module can be imported, otherwise ``False``.
pyvista.has_scheme
Python Library Documentation: function has_scheme in module pyvista.core.utilities.reader_registry
has_scheme(value: 'str') -> 'bool'
Return ``True`` if *value* starts with a URI scheme (e.g. ``https://``).
Parameters
----------
value : str
The string to check.
Returns
-------
bool
``True`` if *value* contains a ``://`` scheme prefix before
the first ``/``.
pyvista.helpers
Python Library Documentation: module pyvista.core.utilities.helpers in pyvista.core.utilities
NAME
pyvista.core.utilities.helpers - Core helper utilities.
FUNCTIONS
axis_rotation(points: 'NumpyArray[float]', angle: 'float', inplace: 'bool' = False, deg: 'bool' = True, axis='z')
Rotate points by angle about an axis.
Parameters
----------
points : numpy.ndarray
Array of points with shape ``(N, 3)``.
angle : float
Rotation angle.
inplace : bool, default: False
Updates points in-place while returning nothing.
deg : bool, default: True
If ``True``, the angle is interpreted as degrees instead of
radians.
axis : str, default: "z"
Name of axis to rotate about. Valid options are ``'x'``, ``'y'``,
and ``'z'``.
Returns
-------
numpy.ndarray
Rotated points.
Examples
--------
Rotate a set of points by 90 degrees about the x-axis in-place.
>>> import numpy as np
>>> import pyvista as pv
>>> from pyvista import examples
>>> points = examples.load_airplane().points
>>> points_orig = points.copy()
>>> pv.axis_rotation(points, 90, axis='x', deg=True, inplace=True)
>>> assert np.all(np.isclose(points[:, 0], points_orig[:, 0]))
>>> assert np.all(np.isclose(points[:, 1], -points_orig[:, 2]))
>>> assert np.all(np.isclose(points[:, 2], points_orig[:, 1]))
generate_plane(normal: 'VectorLike[float]', origin: 'VectorLike[float]')
Return a :vtk:`vtkPlane`.
Parameters
----------
normal : sequence[float]
Three item sequence representing the normal of the plane.
origin : sequence[float]
Three item sequence representing the origin of the plane.
Returns
-------
:vtk:`vtkPlane`
VTK plane.
is_inside_bounds(point, bounds)
Check if a point is inside a set of bounds.
This is implemented through recursion so that this is N-dimensional.
Parameters
----------
point : sequence[float]
Three item cartesian point (i.e. ``[x, y, z]``).
bounds : sequence[float]
Six item bounds in the form of ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
Returns
-------
bool
``True`` when ``point`` is inside ``bounds``.
is_pyvista_dataset(obj: 'Any') -> 'TypeIs[DataSet | MultiBlock | PartitionedDataSet]'
Return ``True`` if the object is a PyVista wrapped dataset.
Parameters
----------
obj : Any
Any object to test.
Returns
-------
bool
``True`` when the object is a :class:`pyvista.DataSet`.
wrap(dataset: '_WrappableVTKDataObjectType | DataObject | trimesh.Trimesh | meshio.Mesh | _vtk.vtkAbstractArray | NumpyArray[float] | None', *, validate: 'bool | None' = None) -> 'DataObject | pyvista_ndarray | None'
Wrap any given VTK data object to its appropriate PyVista data object.
Other formats that are supported include:
* 2D :class:`numpy.ndarray` of XYZ vertices
* 3D :class:`numpy.ndarray` representing a volume. Values will be scalars.
* 3D :class:`trimesh.Trimesh` mesh using :func:`~pyvista.from_trimesh`.
* 3D :class:`meshio.Mesh` mesh using :func:`~pyvista.from_meshio`.
.. versionchanged:: 0.38.0
If the passed object is already a wrapped PyVista object, then
this is no-op and will return that object directly. In previous
versions of PyVista, this would perform a shallow copy.
.. versionchanged:: 0.47
If wrapping a ``Trimesh`` object, any arrays are now wrapped directly
(no copies).
Parameters
----------
dataset : :class:`numpy.ndarray` | :class:`trimesh.Trimesh` | vtk.DataSet
Dataset to wrap.
validate : bool, optional
When ``True``, confirm that every point and cell data array on the
wrapped VTK dataset has a tuple count that matches the dataset's
point or cell count, and emit a :class:`~pyvista.InvalidMeshWarning`
on any mismatch. When ``False``, skip the check entirely. When
``None`` (the default), honor
:attr:`pyvista.core.config.Config.validate_on_wrap` (which itself
defaults to ``True``).
Pass ``validate=False`` in hot loops where the caller already trusts
the input, or set
``pyvista.global_config.validate_on_wrap = False`` to disable the
check globally. This only affects raw VTK dataset inputs;
``meshio`` and ``trimesh`` paths perform their own checks
independently.
.. versionadded:: 0.48
Returns
-------
pyvista.DataSet
The PyVista wrapped dataset.
See Also
--------
:ref:`wrap_trimesh_example`
Examples
--------
Wrap a numpy array representing a random point cloud.
>>> import numpy as np
>>> import pyvista as pv
>>> points = np.random.default_rng().random((10, 3))
>>> cloud = pv.wrap(points)
>>> cloud
PolyData (...)
N Cells: 10
N Points: 10
N Strips: 0
X Bounds: ...
Y Bounds: ...
Z Bounds: ...
N Arrays: 0
Wrap a VTK object.
>>> import pyvista as pv
>>> import vtk
>>> points = vtk.vtkPoints()
>>> p = [1.0, 2.0, 3.0]
>>> vertices = vtk.vtkCellArray()
>>> pid = points.InsertNextPoint(p)
>>> _ = vertices.InsertNextCell(1)
>>> _ = vertices.InsertCellPoint(pid)
>>> point = vtk.vtkPolyData()
>>> _ = point.SetPoints(points)
>>> _ = point.SetVerts(vertices)
>>> mesh = pv.wrap(point)
>>> mesh
PolyData (...)
N Cells: 1
N Points: 1
N Strips: 0
X Bounds: 1.000e+00, 1.000e+00
Y Bounds: 2.000e+00, 2.000e+00
Z Bounds: 3.000e+00, 3.000e+00
N Arrays: 0
Wrap a Trimesh object.
>>> import trimesh
>>> import pyvista as pv
>>> points = [[0, 0, 0], [0, 0, 1], [0, 1, 0]]
>>> faces = [[0, 1, 2]]
>>> tmesh = trimesh.Trimesh(points, faces=faces, process=False)
>>> mesh = pv.wrap(tmesh)
>>> mesh # doctest:+SKIP
PolyData (0x7fc55ff27ad0)
N Cells: 1
N Points: 3
X Bounds: 0.000e+00, 0.000e+00
Y Bounds: 0.000e+00, 1.000e+00
Z Bounds: 0.000e+00, 1.000e+00
N Arrays: 0
DATA
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
TYPE_CHECKING = False
TypeIs = typing_extensions.TypeIs
Special typing form used to annotate the return type of a user-defined
type narrower function. ``TypeIs`` only accepts a single type argument.
At runtime, functions marked this way should return a boolean.
``TypeIs`` aims to benefit *type narrowing* -- a technique used by static
type checkers to determine a more precise type of an expression within a
program's code flow. Usually type narrowing is done by analyzing
conditional code flow and applying the narrowing to a block of code. The
conditional expression here is sometimes referred to as a "type guard".
Sometimes it would be convenient to use a user-defined boolean function
as a type guard. Such a function should use ``TypeIs[...]`` as its
return type to alert static type checkers to this intention.
Using ``-> TypeIs`` tells the static type checker that for a given
function:
1. The return value is a boolean.
2. If the return value is ``True``, the type of its argument
is the intersection of the type inside ``TypeIs`` and the argument's
previously known type.
For example::
def is_awaitable(val: object) -> TypeIs[Awaitable[Any]]:
return hasattr(val, '__await__')
def f(val: Union[int, Awaitable[int]]) -> int:
if is_awaitable(val):
assert_type(val, Awaitable[int])
else:
assert_type(val, int)
``TypeIs`` also works with type variables. For more information, see
PEP 742 (Narrowing types with TypeIs).
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\helpers.py
pyvista.image_sources
Python Library Documentation: module pyvista.core.utilities.image_sources in pyvista.core.utilities
NAME
pyvista.core.utilities.image_sources - Provide sources for generating images.
CLASSES
pyvista.core._vtk_utilities.DisableVtkSnakeCase(builtins.object)
ImageEllipsoidSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageEllipsoidSource)
ImageGaussianSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageGaussianSource)
ImageGridSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageGridSource)
ImageMandelbrotSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageMandelbrotSource)
ImageNoiseSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageNoiseSource)
ImageSinusoidSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageSinusoidSource)
pyvista.core.utilities.misc._NoNewAttrMixin(builtins.object)
ImageEllipsoidSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageEllipsoidSource)
ImageGaussianSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageGaussianSource)
ImageGridSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageGridSource)
ImageMandelbrotSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageMandelbrotSource)
ImageNoiseSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageNoiseSource)
ImageSinusoidSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageSinusoidSource)
vtkmodules.vtkImagingSources.vtkImageEllipsoidSource(vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm)
ImageEllipsoidSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageEllipsoidSource)
vtkmodules.vtkImagingSources.vtkImageGaussianSource(vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm)
ImageGaussianSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageGaussianSource)
vtkmodules.vtkImagingSources.vtkImageGridSource(vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm)
ImageGridSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageGridSource)
vtkmodules.vtkImagingSources.vtkImageMandelbrotSource(vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm)
ImageMandelbrotSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageMandelbrotSource)
vtkmodules.vtkImagingSources.vtkImageNoiseSource(vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm)
ImageNoiseSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageNoiseSource)
vtkmodules.vtkImagingSources.vtkImageSinusoidSource(vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm)
ImageSinusoidSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageSinusoidSource)
class ImageEllipsoidSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageEllipsoidSource)
| ImageEllipsoidSource(*args, **kwargs) -> '_T'
|
| Create a binary image of an ellipsoid class.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| whole_extent : sequence[int]
| The extent of the whole output image.
|
| center : sequence[float]
| The center of the ellipsoid.
|
| radius : tuple
| The radius of the ellipsoid.
|
| Examples
| --------
| Create an image of an ellipsoid.
|
| >>> import pyvista as pv
| >>> source = pv.ImageEllipsoidSource(
| ... whole_extent=(0, 20, 0, 20, 0, 0),
| ... center=(10, 10, 0),
| ... radius=(3, 4, 5),
| ... )
| >>> source.output.plot(cpos='xy')
|
| Method resolution order:
| ImageEllipsoidSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkImagingSources.vtkImageEllipsoidSource
| vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, whole_extent=None, center=None, radius=None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output image as a ImageData.
|
| Returns
| -------
| pyvista.ImageData
| The output image.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Get the center of the ellipsoid.
|
| Returns
| -------
| tuple[float, float, float]
| The center of the ellipsoid.
|
| radius
| Get the radius of the ellipsoid.
|
| Returns
| -------
| sequence[float]
| The radius of the ellipsoid.
|
| whole_extent
| Get extent of the whole output image.
|
| Returns
| -------
| sequence[int]
| The extent of the whole output image.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkImagingSources.vtkImageEllipsoidSource:
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetInValue(...)
| GetInValue(self) -> float
| C++: virtual double GetInValue()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOutValue(...)
| GetOutValue(self) -> float
| C++: virtual double GetOutValue()
|
| GetOutputScalarType(...)
| GetOutputScalarType(self) -> int
| C++: virtual int GetOutputScalarType()
|
| GetRadius(...)
| GetRadius(self) -> (float, float, float)
| C++: virtual double *GetRadius()
|
| GetWholeExtent(...)
| GetWholeExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetWholeExtent(int extent[6])
| GetWholeExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetWholeExtent()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkImageEllipsoidSource
| C++: vtkImageEllipsoidSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkImageEllipsoidSource
| C++: static vtkImageEllipsoidSource *SafeDownCast(
| vtkObjectBase *o)
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set/Get the center of the ellipsoid.
|
| SetInValue(...)
| SetInValue(self, _arg:float) -> None
| C++: virtual void SetInValue(double _arg)
|
| Set/Get the inside pixel values.
|
| SetOutValue(...)
| SetOutValue(self, _arg:float) -> None
| C++: virtual void SetOutValue(double _arg)
|
| Set/Get the outside pixel values.
|
| SetOutputScalarType(...)
| SetOutputScalarType(self, _arg:int) -> None
| C++: virtual void SetOutputScalarType(int _arg)
|
| Set what type of scalar data this source should generate.
|
| SetOutputScalarTypeToChar(...)
| SetOutputScalarTypeToChar(self) -> None
| C++: void SetOutputScalarTypeToChar()
|
| SetOutputScalarTypeToDouble(...)
| SetOutputScalarTypeToDouble(self) -> None
| C++: void SetOutputScalarTypeToDouble()
|
| SetOutputScalarTypeToFloat(...)
| SetOutputScalarTypeToFloat(self) -> None
| C++: void SetOutputScalarTypeToFloat()
|
| SetOutputScalarTypeToInt(...)
| SetOutputScalarTypeToInt(self) -> None
| C++: void SetOutputScalarTypeToInt()
|
| SetOutputScalarTypeToLong(...)
| SetOutputScalarTypeToLong(self) -> None
| C++: void SetOutputScalarTypeToLong()
|
| SetOutputScalarTypeToShort(...)
| SetOutputScalarTypeToShort(self) -> None
| C++: void SetOutputScalarTypeToShort()
|
| SetOutputScalarTypeToUnsignedChar(...)
| SetOutputScalarTypeToUnsignedChar(self) -> None
| C++: void SetOutputScalarTypeToUnsignedChar()
|
| SetOutputScalarTypeToUnsignedInt(...)
| SetOutputScalarTypeToUnsignedInt(self) -> None
| C++: void SetOutputScalarTypeToUnsignedInt()
|
| SetOutputScalarTypeToUnsignedLong(...)
| SetOutputScalarTypeToUnsignedLong(self) -> None
| C++: void SetOutputScalarTypeToUnsignedLong()
|
| SetOutputScalarTypeToUnsignedShort(...)
| SetOutputScalarTypeToUnsignedShort(self) -> None
| C++: void SetOutputScalarTypeToUnsignedShort()
|
| SetRadius(...)
| SetRadius(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetRadius(double _arg1, double _arg2,
| double _arg3)
| SetRadius(self, _arg:(float, float, float)) -> None
| C++: virtual void SetRadius(const double _arg[3])
|
| Set/Get the radius of the ellipsoid.
|
| SetWholeExtent(...)
| SetWholeExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void SetWholeExtent(int extent[6])
| SetWholeExtent(self, minX:int, maxX:int, minY:int, maxY:int,
| minZ:int, maxZ:int) -> None
| C++: void SetWholeExtent(int minX, int maxX, int minY, int maxY,
| int minZ, int maxZ)
|
| Set/Get the extent of the whole output image.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkImagingSources.vtkImageEllipsoidSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkImagingSources.vtkImageEllipsoidSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkImagingSources.vtkImageEllipsoidSource:
|
| __this__
| Pointer to the C++ object.
|
| in_value
| read-write, calls GetInValue/SetInValue
|
| out_value
| read-write, calls GetOutValue/SetOutValue
|
| output_scalar_type
| read-write, calls GetOutputScalarType/SetOutputScalarType
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkImagingSources.vtkImageEllipsoidSource:
|
| __vtkname__ = 'vtkImageEllipsoidSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: virtual void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: virtual void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| GetImageDataInput(...)
| GetImageDataInput(self, port:int) -> vtkImageData
| C++: vtkImageData *GetImageDataInput(int port)
|
| GetInput(...)
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
|
| Get a data object for one of the input port connections. The use
| of this method is strongly discouraged, but some filters that
| were written a long time ago still use this method.
|
| GetOutput(...)
| GetOutput(self) -> vtkImageData
| C++: vtkImageData *GetOutput()
| GetOutput(self, __a:int) -> vtkImageData
| C++: vtkImageData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class ImageGaussianSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageGaussianSource)
| ImageGaussianSource(*args, **kwargs) -> '_T'
|
| Create a binary image with Gaussian pixel values.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| center : sequence[float]
| The center of the gaussian.
|
| whole_extent : sequence[int]
| The extent of the whole output image.
|
| maximum : float
| The maximum value of the gaussian.
|
| std : sequence[float]
| The standard deviation of the gaussian.
|
| Examples
| --------
| Create an image of Gaussian pixel values.
|
| >>> import pyvista as pv
| >>> source = pv.ImageGaussianSource(
| ... center=(100, 100, 0),
| ... whole_extent=(0, 200, 0, 200, 0, 0),
| ... maximum=255,
| ... std=100.0,
| ... )
| >>> source.output.plot(cpos='xy')
|
| Method resolution order:
| ImageGaussianSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkImagingSources.vtkImageGaussianSource
| vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, center=None, whole_extent=None, maximum=None, std=None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output image as a ImageData.
|
| Returns
| -------
| pyvista.ImageData
| The output image.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| center
| Get the center of the gaussian.
|
| Returns
| -------
| tuple[float, float, float]
| The center of the gaussian.
|
| maximum
| Get the maximum value of the gaussian.
|
| Returns
| -------
| float
| The maximum value of the gaussian.
|
| std
| Get the standard deviation of the gaussian.
|
| Returns
| -------
| float
| The standard deviation of the gaussian.
|
| whole_extent
| Get extent of the whole output image.
|
| Returns
| -------
| sequence[int]
| The extent of the whole output image.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkImagingSources.vtkImageGaussianSource:
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: virtual double *GetCenter()
|
| GetMaximum(...)
| GetMaximum(self) -> float
| C++: virtual double GetMaximum()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetStandardDeviation(...)
| GetStandardDeviation(self) -> float
| C++: virtual double GetStandardDeviation()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkImageGaussianSource
| C++: vtkImageGaussianSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkImageGaussianSource
| C++: static vtkImageGaussianSource *SafeDownCast(vtkObjectBase *o)
|
| SetCenter(...)
| SetCenter(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetCenter(double _arg1, double _arg2,
| double _arg3)
| SetCenter(self, _arg:(float, float, float)) -> None
| C++: virtual void SetCenter(const double _arg[3])
|
| Set/Get the center of the Gaussian.
|
| SetMaximum(...)
| SetMaximum(self, _arg:float) -> None
| C++: virtual void SetMaximum(double _arg)
|
| Set/Get the Maximum value of the gaussian
|
| SetStandardDeviation(...)
| SetStandardDeviation(self, _arg:float) -> None
| C++: virtual void SetStandardDeviation(double _arg)
|
| Set/Get the standard deviation of the gaussian
|
| SetWholeExtent(...)
| SetWholeExtent(self, xMin:int, xMax:int, yMin:int, yMax:int,
| zMin:int, zMax:int) -> None
| C++: void SetWholeExtent(int xMin, int xMax, int yMin, int yMax,
| int zMin, int zMax)
|
| Set/Get the extent of the whole output image.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkImagingSources.vtkImageGaussianSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkImagingSources.vtkImageGaussianSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkImagingSources.vtkImageGaussianSource:
|
| __this__
| Pointer to the C++ object.
|
| standard_deviation
| read-write, calls GetStandardDeviation/SetStandardDeviation
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkImagingSources.vtkImageGaussianSource:
|
| __vtkname__ = 'vtkImageGaussianSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: virtual void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: virtual void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| GetImageDataInput(...)
| GetImageDataInput(self, port:int) -> vtkImageData
| C++: vtkImageData *GetImageDataInput(int port)
|
| GetInput(...)
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
|
| Get a data object for one of the input port connections. The use
| of this method is strongly discouraged, but some filters that
| were written a long time ago still use this method.
|
| GetOutput(...)
| GetOutput(self) -> vtkImageData
| C++: vtkImageData *GetOutput()
| GetOutput(self, __a:int) -> vtkImageData
| C++: vtkImageData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class ImageGridSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageGridSource)
| ImageGridSource(*args, **kwargs) -> '_T'
|
| Create an image of a grid.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| origin : sequence[float]
| The origin of the grid.
|
| extent : sequence[int]
| The extent of the whole output image, Default: (0,255,0,255,0,0).
|
| spacing : tuple
| The pixel spacing.
|
| Examples
| --------
| Create an image of a grid.
|
| >>> import pyvista as pv
| >>> source = pv.ImageGridSource(
| ... extent=(0, 20, 0, 20, 0, 0),
| ... spacing=(1, 1, 1),
| ... )
| >>> source.output.plot(cpos='xy')
|
| Method resolution order:
| ImageGridSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkImagingSources.vtkImageGridSource
| vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, origin=None, extent=None, spacing=None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output image as a ImageData.
|
| Returns
| -------
| pyvista.ImageData
| The output image.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| extent
| Get extent of the whole output image.
|
| Returns
| -------
| sequence[int]
| The extent of the whole output image.
|
| origin
| Get the origin of the data.
|
| Returns
| -------
| sequence[float]
| The origin of the grid.
|
| spacing
| Get the spacing of the grid.
|
| Returns
| -------
| sequence[float]
| The pixel spacing.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkImagingSources.vtkImageGridSource:
|
| GetDataExtent(...)
| GetDataExtent(self) -> (int, int, int, int, int, int)
| C++: virtual int *GetDataExtent()
|
| GetDataOrigin(...)
| GetDataOrigin(self) -> (float, float, float)
| C++: virtual double *GetDataOrigin()
|
| GetDataScalarType(...)
| GetDataScalarType(self) -> int
| C++: virtual int GetDataScalarType()
|
| GetDataScalarTypeAsString(...)
| GetDataScalarTypeAsString(self) -> str
| C++: const char *GetDataScalarTypeAsString()
|
| GetDataSpacing(...)
| GetDataSpacing(self) -> (float, float, float)
| C++: virtual double *GetDataSpacing()
|
| GetFillValue(...)
| GetFillValue(self) -> float
| C++: virtual double GetFillValue()
|
| GetGridOrigin(...)
| GetGridOrigin(self) -> (int, int, int)
| C++: virtual int *GetGridOrigin()
|
| GetGridSpacing(...)
| GetGridSpacing(self) -> (int, int, int)
| C++: virtual int *GetGridSpacing()
|
| GetLineValue(...)
| GetLineValue(self) -> float
| C++: virtual double GetLineValue()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkImageGridSource
| C++: vtkImageGridSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkImageGridSource
| C++: static vtkImageGridSource *SafeDownCast(vtkObjectBase *o)
|
| SetDataExtent(...)
| SetDataExtent(self, _arg1:int, _arg2:int, _arg3:int, _arg4:int,
| _arg5:int, _arg6:int) -> None
| C++: virtual void SetDataExtent(int _arg1, int _arg2, int _arg3,
| int _arg4, int _arg5, int _arg6)
| SetDataExtent(self, _arg:(int, int, int, int, int, int)) -> None
| C++: virtual void SetDataExtent(const int _arg[6])
|
| Set/Get the extent of the whole output image, Default:
| (0,255,0,255,0,0)
|
| SetDataOrigin(...)
| SetDataOrigin(self, _arg1:float, _arg2:float, _arg3:float) -> None
| C++: virtual void SetDataOrigin(double _arg1, double _arg2,
| double _arg3)
| SetDataOrigin(self, _arg:(float, float, float)) -> None
| C++: virtual void SetDataOrigin(const double _arg[3])
|
| Set/Get the origin of the data.
|
| SetDataScalarType(...)
| SetDataScalarType(self, _arg:int) -> None
| C++: virtual void SetDataScalarType(int _arg)
|
| Set/Get the data type of pixels in the imported data. As a
| convenience, the OutputScalarType is set to the same value.
|
| SetDataScalarTypeToDouble(...)
| SetDataScalarTypeToDouble(self) -> None
| C++: void SetDataScalarTypeToDouble()
|
| SetDataScalarTypeToInt(...)
| SetDataScalarTypeToInt(self) -> None
| C++: void SetDataScalarTypeToInt()
|
| SetDataScalarTypeToShort(...)
| SetDataScalarTypeToShort(self) -> None
| C++: void SetDataScalarTypeToShort()
|
| SetDataScalarTypeToUnsignedChar(...)
| SetDataScalarTypeToUnsignedChar(self) -> None
| C++: void SetDataScalarTypeToUnsignedChar()
|
| SetDataScalarTypeToUnsignedShort(...)
| SetDataScalarTypeToUnsignedShort(self) -> None
| C++: void SetDataScalarTypeToUnsignedShort()
|
| SetDataSpacing(...)
| SetDataSpacing(self, _arg1:float, _arg2:float, _arg3:float)
| -> None
| C++: virtual void SetDataSpacing(double _arg1, double _arg2,
| double _arg3)
| SetDataSpacing(self, _arg:(float, float, float)) -> None
| C++: virtual void SetDataSpacing(const double _arg[3])
|
| Set/Get the pixel spacing.
|
| SetFillValue(...)
| SetFillValue(self, _arg:float) -> None
| C++: virtual void SetFillValue(double _arg)
|
| Set the grey level of the fill. Default 0.0.
|
| SetGridOrigin(...)
| SetGridOrigin(self, _arg1:int, _arg2:int, _arg3:int) -> None
| C++: virtual void SetGridOrigin(int _arg1, int _arg2, int _arg3)
| SetGridOrigin(self, _arg:(int, int, int)) -> None
| C++: virtual void SetGridOrigin(const int _arg[3])
|
| Set/Get the grid origin, in ijk integer values. Default (0,0,0).
|
| SetGridSpacing(...)
| SetGridSpacing(self, _arg1:int, _arg2:int, _arg3:int) -> None
| C++: virtual void SetGridSpacing(int _arg1, int _arg2, int _arg3)
| SetGridSpacing(self, _arg:(int, int, int)) -> None
| C++: virtual void SetGridSpacing(const int _arg[3])
|
| Set/Get the grid spacing in pixel units. Default (10,10,0). A
| value of zero means no grid.
|
| SetLineValue(...)
| SetLineValue(self, _arg:float) -> None
| C++: virtual void SetLineValue(double _arg)
|
| Set the grey level of the lines. Default 1.0.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkImagingSources.vtkImageGridSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkImagingSources.vtkImageGridSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkImagingSources.vtkImageGridSource:
|
| __this__
| Pointer to the C++ object.
|
| data_extent
| read-write, calls GetDataExtent/SetDataExtent
|
| data_origin
| read-write, calls GetDataOrigin/SetDataOrigin
|
| data_scalar_type
| read-write, calls GetDataScalarType/SetDataScalarType
|
| data_spacing
| read-write, calls GetDataSpacing/SetDataSpacing
|
| fill_value
| read-write, calls GetFillValue/SetFillValue
|
| grid_origin
| read-write, calls GetGridOrigin/SetGridOrigin
|
| grid_spacing
| read-write, calls GetGridSpacing/SetGridSpacing
|
| line_value
| read-write, calls GetLineValue/SetLineValue
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkImagingSources.vtkImageGridSource:
|
| __vtkname__ = 'vtkImageGridSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: virtual void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: virtual void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| GetImageDataInput(...)
| GetImageDataInput(self, port:int) -> vtkImageData
| C++: vtkImageData *GetImageDataInput(int port)
|
| GetInput(...)
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
|
| Get a data object for one of the input port connections. The use
| of this method is strongly discouraged, but some filters that
| were written a long time ago still use this method.
|
| GetOutput(...)
| GetOutput(self) -> vtkImageData
| C++: vtkImageData *GetOutput()
| GetOutput(self, __a:int) -> vtkImageData
| C++: vtkImageData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class ImageMandelbrotSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageMandelbrotSource)
| ImageMandelbrotSource(*args, **kwargs) -> '_T'
|
| Create an image of the Mandelbrot set.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| whole_extent : sequence[int]
| The extent of the whole output image.
|
| maxiter : int
| The maximum number of iterations.
|
| Examples
| --------
| Create an image of the Mandelbrot set.
|
| >>> import pyvista as pv
| >>> source = pv.ImageMandelbrotSource(
| ... whole_extent=(0, 200, 0, 200, 0, 0),
| ... maxiter=100,
| ... )
| >>> source.output.plot(cpos='xy')
|
| Method resolution order:
| ImageMandelbrotSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkImagingSources.vtkImageMandelbrotSource
| vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, whole_extent=None, maxiter=None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output image as a ImageData.
|
| Returns
| -------
| pyvista.ImageData
| The output image.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| maxiter
| Get the maximum number of iterations.
|
| Returns
| -------
| int
| The maximum number of iterations.
|
| whole_extent
| Get extent of the whole output image.
|
| Returns
| -------
| sequence[int]
| The extent of the whole output image.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkImagingSources.vtkImageMandelbrotSource:
|
| ConstantSizeOff(...)
| ConstantSizeOff(self) -> None
| C++: virtual void ConstantSizeOff()
|
| ConstantSizeOn(...)
| ConstantSizeOn(self) -> None
| C++: virtual void ConstantSizeOn()
|
| CopyOriginAndSample(...)
| CopyOriginAndSample(self, source:vtkImageMandelbrotSource) -> None
| C++: void CopyOriginAndSample(vtkImageMandelbrotSource *source)
|
| Convenience for Viewer. Copy the OriginCX and the SpacingCX.
| What about other parameters ???
|
| GetConstantSize(...)
| GetConstantSize(self) -> int
| C++: virtual vtkTypeBool GetConstantSize()
|
| GetMaximumNumberOfIterations(...)
| GetMaximumNumberOfIterations(self) -> int
| C++: virtual unsigned short GetMaximumNumberOfIterations()
|
| GetMaximumNumberOfIterationsMaxValue(...)
| GetMaximumNumberOfIterationsMaxValue(self) -> int
| C++: virtual unsigned short GetMaximumNumberOfIterationsMaxValue()
|
| GetMaximumNumberOfIterationsMinValue(...)
| GetMaximumNumberOfIterationsMinValue(self) -> int
| C++: virtual unsigned short GetMaximumNumberOfIterationsMinValue()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOriginCX(...)
| GetOriginCX(self) -> (float, float, float, float)
| C++: virtual double *GetOriginCX()
|
| GetProjectionAxes(...)
| GetProjectionAxes(self) -> (int, int, int)
| C++: virtual int *GetProjectionAxes()
|
| GetSampleCX(...)
| GetSampleCX(self) -> (float, float, float, float)
| C++: virtual double *GetSampleCX()
|
| GetSizeCX(...)
| GetSizeCX(self) -> (float, float, float, float)
| C++: double *GetSizeCX()
| GetSizeCX(self, s:[float, float, float, float]) -> None
| C++: void GetSizeCX(double s[4])
|
| GetSubsampleRate(...)
| GetSubsampleRate(self) -> int
| C++: virtual int GetSubsampleRate()
|
| GetSubsampleRateMaxValue(...)
| GetSubsampleRateMaxValue(self) -> int
| C++: virtual int GetSubsampleRateMaxValue()
|
| GetSubsampleRateMinValue(...)
| GetSubsampleRateMinValue(self) -> int
| C++: virtual int GetSubsampleRateMinValue()
|
| GetWholeExtent(...)
| GetWholeExtent(self) -> (int, int, int, int, int, int)
| C++: virtual int *GetWholeExtent()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkImageMandelbrotSource
| C++: vtkImageMandelbrotSource *NewInstance()
|
| Pan(...)
| Pan(self, x:float, y:float, z:float) -> None
| C++: void Pan(double x, double y, double z)
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkImageMandelbrotSource
| C++: static vtkImageMandelbrotSource *SafeDownCast(
| vtkObjectBase *o)
|
| SetConstantSize(...)
| SetConstantSize(self, _arg:int) -> None
| C++: virtual void SetConstantSize(vtkTypeBool _arg)
|
| This flag determines whether the Size or spacing of a data set
| remain constant (when extent is changed). By default, size
| remains constant.
|
| SetMaximumNumberOfIterations(...)
| SetMaximumNumberOfIterations(self, _arg:int) -> None
| C++: virtual void SetMaximumNumberOfIterations(
| unsigned short _arg)
|
| The maximum number of cycles run to see if the value goes over 2
|
| SetOriginCX(...)
| SetOriginCX(self, _arg1:float, _arg2:float, _arg3:float,
| _arg4:float) -> None
| C++: virtual void SetOriginCX(double _arg1, double _arg2,
| double _arg3, double _arg4)
| SetOriginCX(self, _arg:(float, float, float, float)) -> None
| C++: virtual void SetOriginCX(const double _arg[4])
|
| Imaginary and real value for C (constant in equation) and X
| (initial value).
|
| SetProjectionAxes(...)
| SetProjectionAxes(self, x:int, y:int, z:int) -> None
| C++: void SetProjectionAxes(int x, int y, int z)
| SetProjectionAxes(self, a:[int, int, int]) -> None
| C++: void SetProjectionAxes(int a[3])
|
| Set the projection from the 4D space (4 parameters / 2 imaginary
| numbers) to the axes of the 3D Volume. 0=C_Real, 1=C_Imaginary,
| 2=X_Real, 4=X_Imaginary
|
| SetSampleCX(...)
| SetSampleCX(self, _arg1:float, _arg2:float, _arg3:float,
| _arg4:float) -> None
| C++: virtual void SetSampleCX(double _arg1, double _arg2,
| double _arg3, double _arg4)
| SetSampleCX(self, _arg:(float, float, float, float)) -> None
| C++: virtual void SetSampleCX(const double _arg[4])
|
| Imaginary and real value for C (constant in equation) and X
| (initial value).
|
| SetSizeCX(...)
| SetSizeCX(self, cReal:float, cImag:float, xReal:float,
| xImag:float) -> None
| C++: void SetSizeCX(double cReal, double cImag, double xReal,
| double xImag)
|
| Just a different way of setting the sample. This sets the size of
| the 4D volume. SampleCX is computed from size and extent. Size is
| ignored when a dimension i 0 (collapsed).
|
| SetSubsampleRate(...)
| SetSubsampleRate(self, _arg:int) -> None
| C++: virtual void SetSubsampleRate(int _arg)
|
| Set/Get a subsample rate.
|
| SetWholeExtent(...)
| SetWholeExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void SetWholeExtent(int extent[6])
| SetWholeExtent(self, minX:int, maxX:int, minY:int, maxY:int,
| minZ:int, maxZ:int) -> None
| C++: void SetWholeExtent(int minX, int maxX, int minY, int maxY,
| int minZ, int maxZ)
|
| Set/Get the extent of the whole output Volume.
|
| Zoom(...)
| Zoom(self, factor:float) -> None
| C++: void Zoom(double factor)
|
| Convenience for Viewer. Pan 3D volume relative to spacing. Zoom
| constant factor.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkImagingSources.vtkImageMandelbrotSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkImagingSources.vtkImageMandelbrotSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkImagingSources.vtkImageMandelbrotSource:
|
| __this__
| Pointer to the C++ object.
|
| constant_size
| read-write, calls GetConstantSize/SetConstantSize
|
| maximum_number_of_iterations
| read-write, calls GetMaximumNumberOfIterations/SetMaximumNumberOfIterations
|
| origin_cx
| read-write, calls GetOriginCX/SetOriginCX
|
| projection_axes
| read-write, calls GetProjectionAxes/SetProjectionAxes
|
| sample_cx
| read-write, calls GetSampleCX/SetSampleCX
|
| size_cx
| read-write, calls GetSizeCX/SetSizeCX
|
| subsample_rate
| read-write, calls GetSubsampleRate/SetSubsampleRate
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkImagingSources.vtkImageMandelbrotSource:
|
| __vtkname__ = 'vtkImageMandelbrotSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: virtual void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: virtual void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| GetImageDataInput(...)
| GetImageDataInput(self, port:int) -> vtkImageData
| C++: vtkImageData *GetImageDataInput(int port)
|
| GetInput(...)
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
|
| Get a data object for one of the input port connections. The use
| of this method is strongly discouraged, but some filters that
| were written a long time ago still use this method.
|
| GetOutput(...)
| GetOutput(self) -> vtkImageData
| C++: vtkImageData *GetOutput()
| GetOutput(self, __a:int) -> vtkImageData
| C++: vtkImageData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class ImageNoiseSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageNoiseSource)
| ImageNoiseSource(*args, **kwargs) -> '_T'
|
| Create an image filled with uniform noise.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| whole_extent : sequence[int]
| The extent of the whole output image.
|
| minimum : float
| The minimum value for the generated noise.
|
| maximum : float
| The maximum value for the generated noise.
|
| seed : int, optional
| Seed the random number generator with a value.
|
| Examples
| --------
| Create an image of noise.
|
| >>> import pyvista as pv
| >>> source = pv.ImageNoiseSource(
| ... whole_extent=(0, 200, 0, 200, 0, 0),
| ... minimum=0,
| ... maximum=255,
| ... seed=0,
| ... )
| >>> source.output.plot(cpos='xy')
|
| Method resolution order:
| ImageNoiseSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkImagingSources.vtkImageNoiseSource
| vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, whole_extent=(0, 255, 0, 255, 0, 0), minimum=0.0, maximum=1.0, seed=None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| seed(self, value: 'int') -> 'None'
| Seed the random number generator with a value.
|
| Parameters
| ----------
| value : int
| The seed value for the random number generator to use.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output image as a ImageData.
|
| Returns
| -------
| pyvista.ImageData
| The output image.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| maximum
| Get the maximum value for the generated noise.
|
| Returns
| -------
| float
| The maximum value for the generated noise.
|
| minimum
| Get the minimum value for the generated noise.
|
| Returns
| -------
| float
| The minimum value for the generated noise.
|
| whole_extent
| Get extent of the whole output image.
|
| Returns
| -------
| sequence[int]
| The extent of the whole output image.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkImagingSources.vtkImageNoiseSource:
|
| GetMaximum(...)
| GetMaximum(self) -> float
| C++: virtual double GetMaximum()
|
| GetMinimum(...)
| GetMinimum(self) -> float
| C++: virtual double GetMinimum()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkImageNoiseSource
| C++: vtkImageNoiseSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkImageNoiseSource
| C++: static vtkImageNoiseSource *SafeDownCast(vtkObjectBase *o)
|
| SetMaximum(...)
| SetMaximum(self, _arg:float) -> None
| C++: virtual void SetMaximum(double _arg)
|
| SetMinimum(...)
| SetMinimum(self, _arg:float) -> None
| C++: virtual void SetMinimum(double _arg)
|
| Set/Get the minimum and maximum values for the generated noise.
|
| SetWholeExtent(...)
| SetWholeExtent(self, xMinx:int, xMax:int, yMin:int, yMax:int,
| zMin:int, zMax:int) -> None
| C++: void SetWholeExtent(int xMinx, int xMax, int yMin, int yMax,
| int zMin, int zMax)
| SetWholeExtent(self, ext:(int, int, int, int, int, int)) -> None
| C++: void SetWholeExtent(const int ext[6])
|
| Set how large of an image to generate.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkImagingSources.vtkImageNoiseSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkImagingSources.vtkImageNoiseSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkImagingSources.vtkImageNoiseSource:
|
| __this__
| Pointer to the C++ object.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkImagingSources.vtkImageNoiseSource:
|
| __vtkname__ = 'vtkImageNoiseSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: virtual void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: virtual void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| GetImageDataInput(...)
| GetImageDataInput(self, port:int) -> vtkImageData
| C++: vtkImageData *GetImageDataInput(int port)
|
| GetInput(...)
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
|
| Get a data object for one of the input port connections. The use
| of this method is strongly discouraged, but some filters that
| were written a long time ago still use this method.
|
| GetOutput(...)
| GetOutput(self) -> vtkImageData
| C++: vtkImageData *GetOutput()
| GetOutput(self, __a:int) -> vtkImageData
| C++: vtkImageData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class ImageSinusoidSource(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, vtkmodules.vtkImagingSources.vtkImageSinusoidSource)
| ImageSinusoidSource(*args, **kwargs) -> '_T'
|
| Create an image of a sinusoid.
|
| .. versionadded:: 0.44.0
|
| Parameters
| ----------
| whole_extent : sequence[int]
| The extent of the whole output image.
|
| direction : tuple
| The direction vector which determines the sinusoidal orientation.
|
| period : float
| The period of the sinusoid in pixel.
|
| phase : tuple
| The phase of the sinusoid in pixel.
|
| amplitude : float
| The magnitude of the sinusoid.
|
| Examples
| --------
| Create an image of a sinusoid.
|
| >>> import pyvista as pv
| >>> source = pv.ImageSinusoidSource(
| ... whole_extent=(0, 200, 0, 200, 0, 0),
| ... period=20.0,
| ... phase=0.0,
| ... amplitude=255,
| ... direction=(1.0, 0.0, 0.0),
| ... )
| >>> source.output.plot(cpos='xy')
|
| Method resolution order:
| ImageSinusoidSource
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| vtkmodules.vtkImagingSources.vtkImageSinusoidSource
| vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm
| vtkmodules.vtkCommonExecutionModel.vtkAlgorithm
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, whole_extent=None, direction=None, period=None, phase=None, amplitude=None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| output
| Get the output image as a ImageData.
|
| Returns
| -------
| pyvista.ImageData
| The output image.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| amplitude
| Get the magnitude of the sinusoid.
|
| Returns
| -------
| float
| The magnitude of the sinusoid.
|
| direction
| Get the direction of the sinusoid.
|
| Returns
| -------
| sequence[float]
| The direction of the sinusoid.
|
| period
| Get the period of the sinusoid.
|
| Returns
| -------
| float
| The period of the sinusoid in pixel.
|
| phase
| Get the phase of the sinusoid.
|
| Returns
| -------
| sequence[float]
| The phase of the sinusoid in pixel.
|
| whole_extent
| Get extent of the whole output image.
|
| Returns
| -------
| sequence[int]
| The extent of the whole output image.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkImagingSources.vtkImageSinusoidSource:
|
| GetAmplitude(...)
| GetAmplitude(self) -> float
| C++: virtual double GetAmplitude()
|
| GetDirection(...)
| GetDirection(self) -> (float, float, float)
| C++: virtual double *GetDirection()
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetPeriod(...)
| GetPeriod(self) -> float
| C++: virtual double GetPeriod()
|
| GetPhase(...)
| GetPhase(self) -> float
| C++: virtual double GetPhase()
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkImageSinusoidSource
| C++: vtkImageSinusoidSource *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkImageSinusoidSource
| C++: static vtkImageSinusoidSource *SafeDownCast(vtkObjectBase *o)
|
| SetAmplitude(...)
| SetAmplitude(self, _arg:float) -> None
| C++: virtual void SetAmplitude(double _arg)
|
| Set/Get the magnitude of the sinusoid.
|
| SetDirection(...)
| SetDirection(self, __a:float, __b:float, __c:float) -> None
| C++: void SetDirection(double, double, double)
| SetDirection(self, dir:[float, float, float]) -> None
| C++: void SetDirection(double dir[3])
|
| Set/Get the direction vector which determines the sinusoidal
| orientation. The magnitude is ignored.
|
| SetPeriod(...)
| SetPeriod(self, _arg:float) -> None
| C++: virtual void SetPeriod(double _arg)
|
| Set/Get the period of the sinusoid in pixels.
|
| SetPhase(...)
| SetPhase(self, _arg:float) -> None
| C++: virtual void SetPhase(double _arg)
|
| Set/Get the phase: 0->2Pi. 0 => Cosine, pi/2 => Sine.
|
| SetWholeExtent(...)
| SetWholeExtent(self, xMinx:int, xMax:int, yMin:int, yMax:int,
| zMin:int, zMax:int) -> None
| C++: void SetWholeExtent(int xMinx, int xMax, int yMin, int yMax,
| int zMin, int zMax)
|
| Set/Get the extent of the whole output image.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkImagingSources.vtkImageSinusoidSource:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkImagingSources.vtkImageSinusoidSource
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkImagingSources.vtkImageSinusoidSource:
|
| __this__
| Pointer to the C++ object.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkImagingSources.vtkImageSinusoidSource:
|
| __vtkname__ = 'vtkImageSinusoidSource'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| AddInputData(...)
| AddInputData(self, __a:vtkDataObject) -> None
| C++: virtual void AddInputData(vtkDataObject *)
| AddInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: virtual void AddInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| GetImageDataInput(...)
| GetImageDataInput(self, port:int) -> vtkImageData
| C++: vtkImageData *GetImageDataInput(int port)
|
| GetInput(...)
| GetInput(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetInput(int port)
| GetInput(self) -> vtkDataObject
| C++: vtkDataObject *GetInput()
|
| Get a data object for one of the input port connections. The use
| of this method is strongly discouraged, but some filters that
| were written a long time ago still use this method.
|
| GetOutput(...)
| GetOutput(self) -> vtkImageData
| C++: vtkImageData *GetOutput()
| GetOutput(self, __a:int) -> vtkImageData
| C++: vtkImageData *GetOutput(int)
|
| Get the output data object for a port on this algorithm.
|
| SetInputData(...)
| SetInputData(self, __a:vtkDataObject) -> None
| C++: void SetInputData(vtkDataObject *)
| SetInputData(self, __a:int, __b:vtkDataObject) -> None
| C++: void SetInputData(int, vtkDataObject *)
|
| Assign a data object as input. Note that this method does not
| establish a pipeline connection. Use SetInputConnection to setup
| a pipeline connection.
|
| SetOutput(...)
| SetOutput(self, d:vtkDataObject) -> None
| C++: virtual void SetOutput(vtkDataObject *d)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkImageAlgorithm:
|
| input
| read-only, calls GetInput
|
| input_data
| write-only, calls SetInputData
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| ABORTED(...)
| ABORTED() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *ABORTED()
|
| \ingroup InformationKeys
|
| AbortExecuteOff(...)
| AbortExecuteOff(self) -> None
| C++: virtual void AbortExecuteOff()
|
| AbortExecuteOn(...)
| AbortExecuteOn(self) -> None
| C++: virtual void AbortExecuteOn()
|
| AddInputConnection(...)
| AddInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void AddInputConnection(int port,
| vtkAlgorithmOutput *input)
| AddInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void AddInputConnection(vtkAlgorithmOutput *input)
|
| Add a connection to the given input port index. See
| SetInputConnection() for details on input connections. This
| method is the complement to RemoveInputConnection() in that it
| adds only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->AddInputConnection(0, filter1->GetOutputPort(0)).
|
| AddInputDataObject(...)
| AddInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(int port,
| vtkDataObject *data)
| AddInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void AddInputDataObject(vtkDataObject *data)
|
| Add the data-object as an input to this given port. This will add
| a new input connection on the specified port without affecting
| any existing connections on the same input port.
|
| CAN_HANDLE_PIECE_REQUEST(...)
| CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST()
|
| Key that tells the pipeline that a particular algorithm can or
| cannot handle piece request. If a filter cannot handle piece
| requests and is asked for a piece, the executive will flag an
| error. If a structured data source cannot handle piece requests
| but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the
| executive will use an extent translator to split the extent into
| pieces. Otherwise, if a source cannot handle piece requests, the
| executive will ask for the whole data for piece 0 and not execute
| the source for other pieces.\ingroup InformationKeys
|
| CAN_PRODUCE_SUB_EXTENT(...)
| CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT()
|
| This key tells the executive that a particular output port is
| capable of producing an arbitrary subextent of the whole extent.
| Many image sources and readers fall into this category but some
| such as the legacy structured data readers cannot support this
| feature.\ingroup InformationKeys
|
| CheckAbort(...)
| CheckAbort(self) -> bool
| C++: bool CheckAbort()
|
| Checks to see if this filter should abort.
|
| ConvertTotalInputToPortConnection(...)
| ConvertTotalInputToPortConnection(self, ind:int, port:int,
| conn:int) -> None
| C++: void ConvertTotalInputToPortConnection(int ind, int &port,
| int &conn)
|
| Convenience routine to convert from a linear ordering of input
| connections to a port/connection pair.
|
| GetAbortExecute(...)
| GetAbortExecute(self) -> int
| C++: virtual vtkTypeBool GetAbortExecute()
|
| GetAbortOutput(...)
| GetAbortOutput(self) -> bool
| C++: virtual bool GetAbortOutput()
|
| GetContainerAlgorithm(...)
| GetContainerAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetContainerAlgorithm()
|
| GetErrorCode(...)
| GetErrorCode(self) -> int
| C++: virtual unsigned long GetErrorCode()
|
| The error code contains a possible error that occurred while
| reading or writing the file.
|
| GetExecutive(...)
| GetExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetExecutive()
|
| Get this algorithm's executive. If it has none, a default
| executive will be created.
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this algorithm.
|
| GetInputAlgorithm(...)
| GetInputAlgorithm(self, port:int, index:int, algPort:int)
| -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index,
| int &algPort)
| GetInputAlgorithm(self, port:int, index:int) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm(int port, int index)
| GetInputAlgorithm(self) -> vtkAlgorithm
| C++: vtkAlgorithm *GetInputAlgorithm()
|
| Returns the algorithm and the output port index of that algorithm
| connected to a port-index pair.
|
| GetInputArrayInformation(...)
| GetInputArrayInformation(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetInputArrayInformation(int idx)
|
| Get the info object for the specified input array to this
| algorithm
|
| GetInputConnection(...)
| GetInputConnection(self, port:int, index:int)
| -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetInputConnection(int port, int index)
|
| Get the algorithm output port connected to an input port.
|
| GetInputDataObject(...)
| GetInputDataObject(self, port:int, connection:int)
| -> vtkDataObject
| C++: vtkDataObject *GetInputDataObject(int port, int connection)
|
| Get the data object that will contain the algorithm input for the
| given port and given connection.
|
| GetInputExecutive(...)
| GetInputExecutive(self, port:int, index:int) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive(int port, int index)
| GetInputExecutive(self) -> vtkExecutive
| C++: vtkExecutive *GetInputExecutive()
|
| Returns the executive associated with a particular input
| connection.
|
| GetInputInformation(...)
| GetInputInformation(self, port:int, index:int) -> vtkInformation
| C++: vtkInformation *GetInputInformation(int port, int index)
| GetInputInformation(self) -> vtkInformation
| C++: vtkInformation *GetInputInformation()
|
| Return the information object that is associated with a
| particular input connection. This can be used to get meta-data
| coming from the REQUEST_INFORMATION pass and set requests for the
| REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the
| pipeline passes. Use the information objects passed as arguments
| instead.
|
| GetInputPortInformation(...)
| GetInputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetInputPortInformation(int port)
|
| Get the information object associated with an input port. There
| is one input port per kind of input to the algorithm. Each input
| port tells executives what kind of data and downstream requests
| this algorithm can handle for that input.
|
| GetNumberOfInputArraySpecifications(...)
| GetNumberOfInputArraySpecifications(self) -> int
| C++: int GetNumberOfInputArraySpecifications()
|
| Get the number of input array indices that have already been set.
|
| GetNumberOfInputConnections(...)
| GetNumberOfInputConnections(self, port:int) -> int
| C++: int GetNumberOfInputConnections(int port)
|
| Get the number of inputs currently connected to a port.
|
| GetNumberOfInputPorts(...)
| GetNumberOfInputPorts(self) -> int
| C++: int GetNumberOfInputPorts()
|
| Get the number of input ports used by the algorithm.
|
| GetNumberOfOutputPorts(...)
| GetNumberOfOutputPorts(self) -> int
| C++: int GetNumberOfOutputPorts()
|
| Get the number of output ports provided by the algorithm.
|
| GetOutputDataObject(...)
| GetOutputDataObject(self, port:int) -> vtkDataObject
| C++: vtkDataObject *GetOutputDataObject(int port)
|
| Get the data object that will contain the algorithm output for
| the given port.
|
| GetOutputInformation(...)
| GetOutputInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputInformation(int port)
|
| Return the information object that is associated with a
| particular output port. This can be used to set meta-data coming
| during the REQUEST_INFORMATION. NOTE: Do not use this in any of
| the pipeline passes. Use the information objects passed as
| arguments instead.
|
| GetOutputPort(...)
| GetOutputPort(self, index:int) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort(int index)
| GetOutputPort(self) -> vtkAlgorithmOutput
| C++: vtkAlgorithmOutput *GetOutputPort()
|
| Get a proxy object corresponding to the given output port of this
| algorithm. The proxy object can be passed to another algorithm's
| SetInputConnection(), AddInputConnection(), and
| RemoveInputConnection() methods to modify pipeline connectivity.
|
| GetOutputPortInformation(...)
| GetOutputPortInformation(self, port:int) -> vtkInformation
| C++: vtkInformation *GetOutputPortInformation(int port)
|
| Get the information object associated with an output port. There
| is one output port per output from the algorithm. Each output
| port tells executives what kind of upstream requests this
| algorithm can handle for that output.
|
| GetProgress(...)
| GetProgress(self) -> float
| C++: virtual double GetProgress()
|
| Get the execution progress of a process object.
|
| GetProgressObserver(...)
| GetProgressObserver(self) -> vtkProgressObserver
| C++: virtual vtkProgressObserver *GetProgressObserver()
|
| GetProgressScale(...)
| GetProgressScale(self) -> float
| C++: virtual double GetProgressScale()
|
| GetProgressShift(...)
| GetProgressShift(self) -> float
| C++: virtual double GetProgressShift()
|
| GetProgressText(...)
| GetProgressText(self) -> str
| C++: virtual char *GetProgressText()
|
| GetReleaseDataFlag(...)
| GetReleaseDataFlag(self) -> int
| C++: virtual vtkTypeBool GetReleaseDataFlag()
|
| GetTotalNumberOfInputConnections(...)
| GetTotalNumberOfInputConnections(self) -> int
| C++: int GetTotalNumberOfInputConnections()
|
| Get the total number of inputs for this algorithm
|
| GetUpdateExtent(...)
| GetUpdateExtent(self) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent()
| GetUpdateExtent(self, port:int) -> (int, int, int, int, int, int)
| C++: int *GetUpdateExtent(int port)
| GetUpdateExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int,
| z1:int) -> None
| C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1,
| int &z0, int &z1)
| GetUpdateExtent(self, port:int, x0:int, x1:int, y0:int, y1:int,
| z0:int, z1:int) -> None
| C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0,
| int &y1, int &z0, int &z1)
| GetUpdateExtent(self, extent:[int, int, int, int, int, int])
| -> None
| C++: void GetUpdateExtent(int extent[6])
| GetUpdateExtent(self, port:int, extent:[int, int, int, int, int,
| int]) -> None
| C++: void GetUpdateExtent(int port, int extent[6])
|
| These functions return the update extent for output ports that
| use 3D extents. Where port is not specified, it is assumed to be
| 0.
|
| GetUpdateGhostLevel(...)
| GetUpdateGhostLevel(self) -> int
| C++: int GetUpdateGhostLevel()
| GetUpdateGhostLevel(self, port:int) -> int
| C++: int GetUpdateGhostLevel(int port)
|
| GetUpdateNumberOfPieces(...)
| GetUpdateNumberOfPieces(self) -> int
| C++: int GetUpdateNumberOfPieces()
| GetUpdateNumberOfPieces(self, port:int) -> int
| C++: int GetUpdateNumberOfPieces(int port)
|
| GetUpdatePiece(...)
| GetUpdatePiece(self) -> int
| C++: int GetUpdatePiece()
| GetUpdatePiece(self, port:int) -> int
| C++: int GetUpdatePiece(int port)
|
| These functions return the update extent for output ports that
| use piece extents. Where port is not specified, it is assumed to
| be 0.
|
| HasExecutive(...)
| HasExecutive(self) -> int
| C++: vtkTypeBool HasExecutive()
|
| Check whether this algorithm has an assigned executive. This
| will NOT create a default executive.
|
| INPUT_ARRAYS_TO_PROCESS(...)
| INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS(
| )
|
| \ingroup InformationKeys
|
| INPUT_CONNECTION(...)
| INPUT_CONNECTION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_CONNECTION()
|
| \ingroup InformationKeys
|
| INPUT_IS_OPTIONAL(...)
| INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL()
|
| Keys used to specify input port requirements.\ingroup
| InformationKeys
|
| INPUT_IS_REPEATABLE(...)
| INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE()
|
| \ingroup InformationKeys
|
| INPUT_PORT(...)
| INPUT_PORT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *INPUT_PORT()
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_DATA_TYPE(...)
| INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey
| C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE(
| )
|
| \ingroup InformationKeys
|
| INPUT_REQUIRED_FIELDS(...)
| INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS(
| )
|
| \ingroup InformationKeys
|
| ModifyRequest(...)
| ModifyRequest(self, request:vtkInformation, when:int) -> int
| C++: virtual int ModifyRequest(vtkInformation *request, int when)
|
| This method gives the algorithm a chance to modify the contents
| of a request before or after (specified in the when argument) it
| is forwarded. The default implementation is empty. Returns 1 on
| success, 0 on failure. When can be either
| vtkExecutive::BeforeForward or vtkExecutive::AfterForward.
|
| ProcessRequest(...)
| ProcessRequest(self, request:vtkInformation, inInfo:vtkCollection,
| outInfo:vtkInformationVector) -> int
| C++: vtkTypeBool ProcessRequest(vtkInformation *request,
| vtkCollection *inInfo, vtkInformationVector *outInfo)
|
| Version of ProcessRequest() that is wrapped. This converts the
| collection to an array and calls the other version.
|
| PropagateUpdateExtent(...)
| PropagateUpdateExtent(self) -> None
| C++: virtual void PropagateUpdateExtent()
|
| Propagate meta-data upstream.
|
| ReleaseDataFlagOff(...)
| ReleaseDataFlagOff(self) -> None
| C++: void ReleaseDataFlagOff()
|
| ReleaseDataFlagOn(...)
| ReleaseDataFlagOn(self) -> None
| C++: void ReleaseDataFlagOn()
|
| RemoveAllInputConnections(...)
| RemoveAllInputConnections(self, port:int) -> None
| C++: virtual void RemoveAllInputConnections(int port)
|
| Removes all input connections.
|
| RemoveAllInputs(...)
| RemoveAllInputs(self) -> None
| C++: void RemoveAllInputs()
|
| Remove all the input data.
|
| RemoveInputConnection(...)
| RemoveInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void RemoveInputConnection(int port,
| vtkAlgorithmOutput *input)
| RemoveInputConnection(self, port:int, idx:int) -> None
| C++: virtual void RemoveInputConnection(int port, int idx)
|
| Remove a connection from the given input port index. See
| SetInputConnection() for details on input connection. This
| method is the complement to AddInputConnection() in that it
| removes only the connection specified without affecting other
| connections. Typical usage is
|
| * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)).
|
| RemoveNoPriorTemporalAccessInformationKey(...)
| RemoveNoPriorTemporalAccessInformationKey(self) -> None
| C++: void RemoveNoPriorTemporalAccessInformationKey()
|
| Removes any information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()` to
| all output ports of this `vtkAlgorithm`.
|
| ResetInputArraySpecifications(...)
| ResetInputArraySpecifications(self) -> bool
| C++: bool ResetInputArraySpecifications()
|
| Clear all existing input array specifications (as if
| SetInputArrayToProcess had never been called).
|
| This allows users to easily reconfigure a filter that accepts a
| variable number of arrays to process. The return value is true if
| any specifications existed before the call (and thus
| this->Modified() was called) and false otherwise (indicating the
| algorithm was not modified).
|
| SetAbortExecute(...)
| SetAbortExecute(self, _arg:int) -> None
| C++: virtual void SetAbortExecute(vtkTypeBool _arg)
|
| Set/Get the AbortExecute flag for the process object. Process
| objects may handle premature termination of execution in
| different ways.
|
| SetAbortExecuteAndUpdateTime(...)
| SetAbortExecuteAndUpdateTime(self) -> None
| C++: void SetAbortExecuteAndUpdateTime()
|
| Set AbortExecute Flag and update LastAbortTime.
|
| SetAbortOutput(...)
| SetAbortOutput(self, _arg:bool) -> None
| C++: virtual void SetAbortOutput(bool _arg)
|
| Set/Get an internal variable used to communicate between the
| algorithm and executive. If the executive sees this value is set,
| it will initialize the output data and pass the ABORTED flag
| downstream.
|
| CheckAbort sets this value to true if the function returns true.
|
| SetContainerAlgorithm(...)
| SetContainerAlgorithm(self, containerAlg:vtkAlgorithm) -> None
| C++: void SetContainerAlgorithm(vtkAlgorithm *containerAlg)
|
| Set/get a Container algorithm for this algorithm. Allows this
| algorithm to check to abort status of its Container algorithm as
| well as have access to its Container's information.
|
| SetDefaultExecutivePrototype(...)
| SetDefaultExecutivePrototype(proto:vtkExecutive) -> None
| C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto)
|
| If the DefaultExecutivePrototype is set, a copy of it is created
| in CreateDefaultExecutive() using NewInstance().
|
| SetExecutive(...)
| SetExecutive(self, executive:vtkExecutive) -> None
| C++: virtual void SetExecutive(vtkExecutive *executive)
|
| Set this algorithm's executive. This algorithm is removed from
| any executive to which it has previously been assigned and then
| assigned to the given executive.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetInputArrayToProcess(...)
| SetInputArrayToProcess(self, name:str, fieldAssociation:int,
| component:int=...) -> None
| C++: void SetInputArrayToProcess(const char *name,
| int fieldAssociation,
| int component=vtkArrayComponents::AllComponents)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, name:str, component:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, const char *name,
| int component)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:int, fieldAttributeType:int, component:int)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, int fieldAssociation, int fieldAttributeType,
| int component)
| SetInputArrayToProcess(self, idx:int, info:vtkInformation) -> None
| C++: virtual void SetInputArrayToProcess(int idx,
| vtkInformation *info)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str) -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName)
| SetInputArrayToProcess(self, idx:int, port:int, connection:int,
| fieldAssociation:str, attributeTypeorName:str, component:str)
| -> None
| C++: virtual void SetInputArrayToProcess(int idx, int port,
| int connection, const char *fieldAssociation,
| const char *attributeTypeorName, const char *component)
|
| Set the inpu ...
| [Truncated]
|
| SetInputConnection(...)
| SetInputConnection(self, port:int, input:vtkAlgorithmOutput)
| -> None
| C++: virtual void SetInputConnection(int port,
| vtkAlgorithmOutput *input)
| SetInputConnection(self, input:vtkAlgorithmOutput) -> None
| C++: virtual void SetInputConnection(vtkAlgorithmOutput *input)
|
| Set the connection for the given input port index. Each input
| port of a filter has a specific purpose. A port may have zero or
| more connections and the required number is specified by each
| filter. Setting the connection with this method removes all
| other connections from the port. To add more than one connection
| use AddInputConnection().
|
| * The input for the connection is the output port of another
| * filter, which is obtained with GetOutputPort(). Typical usage
| is
|
| * filter2->SetInputConnection(0, filter1->GetOutputPort(0)).
|
| SetInputDataObject(...)
| SetInputDataObject(self, port:int, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(int port,
| vtkDataObject *data)
| SetInputDataObject(self, data:vtkDataObject) -> None
| C++: virtual void SetInputDataObject(vtkDataObject *data)
|
| Sets the data-object as an input on the given port index. Setting
| the input with this method removes all other connections from the
| port. Internally, this method creates a vtkTrivialProducer
| instance and sets that as the input-connection for the given
| port. It is safe to call this method repeatedly with the same
| input data object. The MTime of the vtkAlgorithm will not change
| unless the data object changed.
|
| SetNoPriorTemporalAccessInformationKey(...)
| SetNoPriorTemporalAccessInformationKey(self, key:int) -> None
| C++: void SetNoPriorTemporalAccessInformationKey(int key)
| SetNoPriorTemporalAccessInformationKey(self) -> None
| C++: void SetNoPriorTemporalAccessInformationKey()
|
| Set to all output ports of this algorithm the information key
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS()`.
| This should be set on sources of pipelines for which all
| timesteps are not necessarily all available at once. This is
| typically the case for visualization in situ.
|
| ote Default value in
| `vtkStreamingDemandDrivenPipeline::NO_PRIOR_TEMPORAL_ACCESS_RESET`
| . `vtkStreamingDemandDrivenPipeline` will set it to
| `NO_PRIOR_TEMPORAL_ACCESS_CONTINUE' after execution of the first
| time step.
|
| SetProgressObserver(...)
| SetProgressObserver(self, __a:vtkProgressObserver) -> None
| C++: void SetProgressObserver(vtkProgressObserver *)
|
| If an ProgressObserver is set, the algorithm will report progress
| through it rather than directly. This means that it will call
| UpdateProgress() on the ProgressObserver rather than itself
| report it and set progress. This is most useful in situations
| where multiple threads are executing an algorithm at the same
| time and want to handle progress locally.
|
| SetProgressShiftScale(...)
| SetProgressShiftScale(self, shift:float, scale:float) -> None
| C++: void SetProgressShiftScale(double shift, double scale)
|
| Specify the shift and scale values to use to apply to the
| progress amount when `UpdateProgress` is called. By default shift
| is set to 0, and scale is set to 1.0. This is useful when the
| vtkAlgorithm instance is used as an internal algorithm to solve
| only a part of a whole problem.
|
| If calling on a internal vtkAlgorithm, make sure you take into
| consideration that values set of the outer vtkAlgorithm as well
| since the outer vtkAlgorithm itself may be nested in another
| algorithm.
|
| ote SetProgressShiftScale does not modify the MTime of the
| algorithm.
|
| SetProgressText(...)
| SetProgressText(self, ptext:str) -> None
| C++: void SetProgressText(const char *ptext)
|
| Set the current text message associated with the progress state.
| This may be used by a calling process/GUI. Note: Because
| SetProgressText() is called from inside RequestData() it does not
| modify the algorithm object. Algorithms are not allowed to modify
| themselves from inside RequestData().
|
| SetReleaseDataFlag(...)
| SetReleaseDataFlag(self, __a:int) -> None
| C++: virtual void SetReleaseDataFlag(vtkTypeBool)
|
| Turn release data flag on or off for all output ports.
|
| Update(...)
| Update(self, port:int) -> None
| C++: virtual void Update(int port)
| Update(self) -> None
| C++: virtual void Update()
| Update(self, port:int, requests:vtkInformationVector) -> int
| C++: virtual vtkTypeBool Update(int port,
| vtkInformationVector *requests)
| Update(self, requests:vtkInformation) -> int
| C++: virtual vtkTypeBool Update(vtkInformation *requests)
|
| Bring this algorithm's outputs up-to-date.
|
| UpdateDataObject(...)
| UpdateDataObject(self) -> None
| C++: virtual void UpdateDataObject()
|
| Create output object(s).
|
| UpdateExtent(...)
| UpdateExtent(self, extents:(int, int, int, int, int, int)) -> int
| C++: virtual int UpdateExtent(const int extents[6])
|
| Convenience method to update an algorithm after passing requests
| to its first output port. Supports extent request.
|
| UpdateExtentIsEmpty(...)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation,
| output:vtkDataObject) -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| vtkDataObject *output)
| UpdateExtentIsEmpty(self, pinfo:vtkInformation, extentType:int)
| -> int
| C++: int UpdateExtentIsEmpty(vtkInformation *pinfo,
| int extentType)
|
| This detects when the UpdateExtent will generate no data This
| condition is satisfied when the UpdateExtent has zero volume
| (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this
| call to determine whether to call Execute.
|
| UpdateInformation(...)
| UpdateInformation(self) -> None
| C++: virtual void UpdateInformation()
|
| Bring the algorithm's information up-to-date.
|
| UpdatePiece(...)
| UpdatePiece(self, piece:int, numPieces:int, ghostLevels:int,
| extents:(int, int, int, int, int, int)=...) -> int
| C++: virtual int UpdatePiece(int piece, int numPieces,
| int ghostLevels, const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports piece and
| extent (optional) requests.
|
| UpdateProgress(...)
| UpdateProgress(self, amount:float) -> None
| C++: void UpdateProgress(double amount)
|
| Update the progress of the process object. If a ProgressMethod
| exists, executes it. Then set the Progress ivar to amount. The
| parameter amount should range between (0,1).
|
| UpdateTimeStep(...)
| UpdateTimeStep(self, time:float, piece:int=-1, numPieces:int=1,
| ghostLevels:int=0, extents:(int, int, int, int, int, int)=...)
| -> int
| C++: virtual int UpdateTimeStep(double time, int piece=-1,
| int numPieces=1, int ghostLevels=0,
| const int extents[6]=nullptr)
|
| Convenience method to update an algorithm after passing requests
| to its first output port. See documentation for Update(int port,
| vtkInformationVector* requests) for details. Supports time, piece
| (optional) and extent (optional) requests.
|
| UpdateWholeExtent(...)
| UpdateWholeExtent(self) -> None
| C++: virtual void UpdateWholeExtent()
|
| Bring this algorithm's outputs up-to-date.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Participate in garbage collection.
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| update(...)
| This method updates the pipeline connected to this algorithm
| and returns an Output object with an output property. This property
| provides either a single data object (for algorithms with single output
| or a tuple (for algorithms with multiple outputs).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| abort_execute
| read-write, calls GetAbortExecute/SetAbortExecute
|
| abort_output
| read-write, calls GetAbortOutput/SetAbortOutput
|
| container_algorithm
| read-write, calls GetContainerAlgorithm/SetContainerAlgorithm
|
| default_executive_prototype
| write-only, calls SetDefaultExecutivePrototype
|
| error_code
| read-only, calls GetErrorCode
|
| executive
| read-write, calls GetExecutive/SetExecutive
|
| information
| read-write, calls GetInformation/SetInformation
|
| input_algorithm
| read-only, calls GetInputAlgorithm
|
| input_array_to_process
| write-only, calls SetInputArrayToProcess
|
| input_connection
| write-only, calls SetInputConnection
|
| input_data_object
| write-only, calls SetInputDataObject
|
| input_executive
| read-only, calls GetInputExecutive
|
| input_information
| read-only, calls GetInputInformation
|
| no_prior_temporal_access_information_key
| write-only, calls SetNoPriorTemporalAccessInformationKey
|
| number_of_input_array_specifications
| read-only, calls GetNumberOfInputArraySpecifications
|
| number_of_input_ports
| read-only, calls GetNumberOfInputPorts
|
| number_of_output_ports
| read-only, calls GetNumberOfOutputPorts
|
| output_port
| read-only, calls GetOutputPort
|
| progress
| read-only, calls GetProgress
|
| progress_observer
| read-write, calls GetProgressObserver/SetProgressObserver
|
| progress_scale
| read-only, calls GetProgressScale
|
| progress_shift
| read-only, calls GetProgressShift
|
| progress_shift_scale
| write-only, calls SetProgressShiftScale
|
| progress_text
| read-write, calls GetProgressText/SetProgressText
|
| release_data_flag
| read-write, calls GetReleaseDataFlag/SetReleaseDataFlag
|
| total_number_of_input_connections
| read-only, calls GetTotalNumberOfInputConnections
|
| update_extent
| read-only, calls GetUpdateExtent
|
| update_ghost_level
| read-only, calls GetUpdateGhostLevel
|
| update_number_of_pieces
| read-only, calls GetUpdateNumberOfPieces
|
| update_piece
| read-only, calls GetUpdatePiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonExecutionModel.vtkAlgorithm:
|
| DEFAULT_PRECISION = 2
|
| DOUBLE_PRECISION = 1
|
| DesiredOutputPrecision = <class 'vtkmodules.vtkCommonExecutionModel.vt...
|
| SINGLE_PRECISION = 0
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: virtual vtkMTimeType GetMTime()
|
| Return this object's modified time.
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| m_time
| read-only, calls GetMTime
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
DATA
TYPE_CHECKING = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\image_sources.py
pyvista.is_inside_bounds
Python Library Documentation: function is_inside_bounds in module pyvista.core.utilities.helpers
is_inside_bounds(point, bounds)
Check if a point is inside a set of bounds.
This is implemented through recursion so that this is N-dimensional.
Parameters
----------
point : sequence[float]
Three item cartesian point (i.e. ``[x, y, z]``).
bounds : sequence[float]
Six item bounds in the form of ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
Returns
-------
bool
``True`` when ``point`` is inside ``bounds``.
pyvista.is_meshio_mesh
Python Library Documentation: function is_meshio_mesh in module pyvista.core.utilities.fileio
is_meshio_mesh(obj: 'object') -> 'bool'
Test if passed object is an instance of :class:`meshio.Mesh`.
Parameters
----------
obj : object
Any object.
Returns
-------
bool
``True`` if ``obj`` is a :class:`meshio.Mesh`.
pyvista.is_pyvista_dataset
Python Library Documentation: function is_pyvista_dataset in module pyvista.core.utilities.helpers
is_pyvista_dataset(obj: 'Any') -> 'TypeIs[DataSet | MultiBlock | PartitionedDataSet]'
Return ``True`` if the object is a PyVista wrapped dataset.
Parameters
----------
obj : Any
Any object to test.
Returns
-------
bool
``True`` when the object is a :class:`pyvista.DataSet`.
pyvista.is_trimesh_mesh
Python Library Documentation: function is_trimesh_mesh in module pyvista.core.utilities.fileio
is_trimesh_mesh(obj: 'object') -> 'bool'
Test if passed object is an instance of :class:`trimesh.Trimesh`.
.. versionadded:: 0.47
Parameters
----------
obj : object
Any object.
Returns
-------
bool
``True`` if ``obj`` is a :class:`trimesh.Trimesh`.
pyvista.jupyter
Python Library Documentation: package pyvista.jupyter in pyvista
NAME
pyvista.jupyter - Jupyter notebook plotting module.
PACKAGE CONTENTS
notebook
CLASSES
builtins.tuple(builtins.object)
JupyterBackendRegistration
class JupyterBackendRegistration(builtins.tuple)
| JupyterBackendRegistration(name: ForwardRef('str'), handler: ForwardRef('Callable[..., object]'), source: ForwardRef('str'))
|
| Describe one registered custom Jupyter backend.
|
| Returned by :func:`~pyvista.registered_jupyter_backends`.
|
| .. versionadded:: 0.48.0
|
| Attributes
| ----------
| name : str
| Backend name.
| handler : callable
| The backend handler callable.
| source : str
| Human-readable origin in the form ``'module.qualname'`` for
| explicit registrations or the entry-point ``value`` for
| plugin-discovered registrations.
|
| Method resolution order:
| JupyterBackendRegistration
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.JupyterBackendRegistration
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.JupyterBackendRegistration
| Return a nicely formatted representation string
|
| _asdict(self) from collections.JupyterBackendRegistration
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.JupyterBackendRegistration
| Return a new JupyterBackendRegistration object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.JupyterBackendRegistration
| Make a new JupyterBackendRegistration object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, name: ForwardRef('str'), handler: ForwardRef('Callable[..., object]'), source: ForwardRef('str')) from namedtuple_JupyterBackendRegistration.JupyterBackendRegistration
| Create new instance of JupyterBackendRegistration(name, handler, source)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| name
| Alias for field number 0
|
| handler
| Alias for field number 1
|
| source
| Alias for field number 2
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'handler': ForwardRef('Callable[..., object]'), 'na...
|
| __match_args__ = ('name', 'handler', 'source')
|
| __orig_bases__ = (<function NamedTuple>,)
|
| _field_defaults = {}
|
| _fields = ('name', 'handler', 'source')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
FUNCTIONS
register_jupyter_backend(name: 'str', handler: 'Callable[..., object]', *, override: 'bool' = False) -> 'None'
Register a custom Jupyter backend handler.
.. versionadded:: 0.48.0
Parameters
----------
name : str
Name of the backend (e.g. ``'custom'``). Must not collide with
a built-in backend name unless ``override=True`` is passed.
handler : callable
A callable with signature ``handler(plotter, **kwargs)`` that
returns an IPython-displayable object.
override : bool, default: False
If ``True``, allow registering a name that collides with a
built-in backend. Also silences the warning emitted when
replacing an existing custom registration.
Raises
------
ValueError
If ``name`` collides with a built-in backend and ``override``
is ``False``.
Warns
-----
UserWarning
If ``name`` already refers to a registered custom backend. The
new registration replaces the old one (last wins); pass
``override=True`` to silence the warning.
Examples
--------
>>> import pyvista as pv
>>> def my_handler(plotter, **kwargs): ...
>>> pv.register_jupyter_backend('my_backend', my_handler) # doctest: +SKIP
registered_jupyter_backends() -> 'tuple[JupyterBackendRegistration, ...]'
Return every custom Jupyter backend currently registered.
Forces discovery of any pending entry-point plugins so the returned
list reflects every backend visible to PyVista. A plugin that fails
to import emits a ``UserWarning`` and is skipped; the rest still
appear in the result.
.. versionadded:: 0.48.0
Returns
-------
tuple[JupyterBackendRegistration, ...]
One record per registered backend. Each record exposes
``name``, ``handler``, and ``source``. Built-in backends are
not included; only custom registrations.
set_jupyter_backend(backend: 'JupyterBackendOptions | str', name=None, **kwargs)
Set the plotting backend for a jupyter notebook.
Parameters
----------
backend : str
Jupyter backend to use when plotting. Must be one of the following:
* ``'static'`` : Display a single static image within the
Jupyterlab environment. Still requires that a virtual
framebuffer be set up when displaying on a headless server,
but does not require any additional modules to be installed.
* ``'client'`` : Export/serialize the scene graph to be rendered
with VTK.js client-side through ``trame``. Requires ``trame``
and ``jupyter-server-proxy`` to be installed.
* ``'server'``: Render remotely and stream the resulting VTK
images back to the client using ``trame``. This replaces the
``'ipyvtklink'`` backend with better performance.
Supports the most VTK features, but suffers from minor lag due
to remote rendering. Requires that a virtual framebuffer be set
up when displaying on a headless server. Must have at least ``trame``
and ``jupyter-server-proxy`` installed for cloud/remote Jupyter
instances. This mode is also aliased by ``'trame'``.
* ``'trame'``: The full Trame-based backend that combines both
``'server'`` and ``'client'`` into one backend. This requires a
virtual frame buffer.
* ``'html'`` : Export/serialize the scene graph to be rendered
with the Trame client backend but in a static HTML file.
* ``'none'`` : Do not display any plots within jupyterlab,
instead display using dedicated VTK render windows. This
will generate nothing on headless servers even with a
virtual framebuffer.
Custom backends registered via :func:`~pyvista.register_jupyter_backend`
are also accepted. Pass ``None`` to reset to auto-detection at display
time.
name : str, optional
The unique name identifier for the server.
**kwargs : dict, optional
Any additional keyword arguments to pass to the server launch.
Examples
--------
Enable the trame Trame backend.
>>> pv.set_jupyter_backend('trame') # doctest:+SKIP
Just show static images.
>>> pv.set_jupyter_backend('static') # doctest:+SKIP
Disable all plotting within JupyterLab and display using a
standard desktop VTK render window.
>>> pv.set_jupyter_backend('none') # doctest:+SKIP
Reset to auto-detect the best available backend.
>>> pv.set_jupyter_backend(None) # doctest:+SKIP
DATA
ALLOWED_BACKENDS = ('static', 'client', 'server', 'trame', 'html', 'no...
JUPYTER_BACKEND_ENTRY_POINT_GROUP = 'pyvista.jupyter_backends'
JupyterBackendOptions = typing.Literal['static', 'client', 'server', '...
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
TypeIs = typing_extensions.TypeIs
Special typing form used to annotate the return type of a user-defined
type narrower function. ``TypeIs`` only accepts a single type argument.
At runtime, functions marked this way should return a boolean.
``TypeIs`` aims to benefit *type narrowing* -- a technique used by static
type checkers to determine a more precise type of an expression within a
program's code flow. Usually type narrowing is done by analyzing
conditional code flow and applying the narrowing to a block of code. The
conditional expression here is sometimes referred to as a "type guard".
Sometimes it would be convenient to use a user-defined boolean function
as a type guard. Such a function should use ``TypeIs[...]`` as its
return type to alert static type checkers to this intention.
Using ``-> TypeIs`` tells the static type checker that for a given
function:
1. The return value is a boolean.
2. If the return value is ``True``, the type of its argument
is the intersection of the type inside ``TypeIs`` and the argument's
previously known type.
For example::
def is_awaitable(val: object) -> TypeIs[Awaitable[Any]]:
return hasattr(val, '__await__')
def f(val: Union[int, Awaitable[int]]) -> int:
if is_awaitable(val):
assert_type(val, Awaitable[int])
else:
assert_type(val, int)
``TypeIs`` also works with type variables. For more information, see
PEP 742 (Narrowing types with TypeIs).
__annotations__ = {'_custom_backend_sources': 'dict[str, str]', '_cust...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\jupyter\__init__.py
pyvista.line_segments_from_points
Python Library Documentation: function line_segments_from_points in module pyvista.core.utilities.points
line_segments_from_points(points: 'VectorLike[float] | MatrixLike[float]') -> 'PolyData'
Generate non-connected line segments from points.
Assumes points are ordered as line segments and an even number of
points.
Parameters
----------
points : array_like[float]
Points representing line segments. An even number must be
given as every two vertices represent a single line
segment. For example, two line segments would be represented
as ``np.array([[0, 0, 0], [1, 0, 0], [1, 0, 0], [1, 1, 0]])``.
Returns
-------
pyvista.PolyData
PolyData with lines and cells.
Examples
--------
This example plots two line segments at right angles to each other.
>>> import pyvista as pv
>>> import numpy as np
>>> points = np.array([[0, 0, 0], [1, 0, 0], [1, 0, 0], [1, 1, 0]])
>>> lines = pv.line_segments_from_points(points)
>>> lines.plot()
See :ref:`graph_network_example` for more examples using this function.
pyvista.lines_from_points
Python Library Documentation: function lines_from_points in module pyvista.core.utilities.points
lines_from_points(points: 'VectorLike[float] | MatrixLike[float]', close: 'bool' = False) -> 'PolyData'
Make a connected line set given an array of points.
Parameters
----------
points : array_like[float]
Points representing the vertices of the connected
segments. For example, two line segments would be represented
as ``np.array([[0, 0, 0], [1, 0, 0], [1, 1, 0]])``.
close : bool, default: False
If ``True``, close the line segments into a loop.
Returns
-------
pyvista.PolyData
PolyData with lines and cells.
Examples
--------
>>> import numpy as np
>>> import pyvista as pv
>>> points = np.array([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
>>> poly = pv.lines_from_points(points)
>>> poly.plot(line_width=5)
See :ref:`lorenz_attractor_example` for more examples using this function.
pyvista.make_tri_mesh
Python Library Documentation: function make_tri_mesh in module pyvista.core.utilities.points
make_tri_mesh(points: 'NumpyArray[float]', faces: 'NumpyArray[int]') -> 'PolyData'
Construct a ``pyvista.PolyData`` mesh using points and faces arrays.
Construct a mesh from an Nx3 array of points and an Mx3 array of
triangle indices, resulting in a mesh with N vertices and M
triangles. This function does not require the standard VTK
"padding" column and simplifies mesh creation.
Parameters
----------
points : np.ndarray
Array of points with shape ``(N, 3)`` storing the vertices of the
triangle mesh.
faces : np.ndarray
Array of indices with shape ``(M, 3)`` containing the triangle
indices.
Returns
-------
pyvista.PolyData
PolyData instance containing the triangle mesh.
Examples
--------
This example discretizes the unit square into a triangle mesh with
nine vertices and eight faces.
>>> import numpy as np
>>> import pyvista as pv
>>> points = np.array(
... [
... [0, 0, 0],
... [0.5, 0, 0],
... [1, 0, 0],
... [0, 0.5, 0],
... [0.5, 0.5, 0],
... [1, 0.5, 0],
... [0, 1, 0],
... [0.5, 1, 0],
... [1, 1, 0],
... ]
... )
>>> faces = np.array(
... [
... [0, 1, 4],
... [4, 7, 6],
... [2, 5, 4],
... [4, 5, 8],
... [0, 4, 3],
... [3, 4, 6],
... [1, 2, 4],
... [4, 8, 7],
... ]
... )
>>> tri_mesh = pv.make_tri_mesh(points, faces)
>>> tri_mesh.plot(show_edges=True, line_width=5)
pyvista.merge
Python Library Documentation: function merge in module pyvista.core.utilities.features
merge(datasets, merge_points: 'bool' = True, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
Merge several datasets.
.. note::
The behavior of this filter varies from the
:func:`PolyDataFilters.boolean_union` filter. This filter
does not attempt to create a manifold mesh and will include
internal surfaces when two meshes overlap.
.. warning::
The merge order of this filter depends on the installed version
of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
This may be a breaking change for some applications. If only
merging two meshes, it may be possible to maintain `some` backwards
compatibility by swapping the input order of the two meshes,
though this may also affect the merged arrays and is therefore
not fully backwards-compatible.
Parameters
----------
datasets : sequence[:class:`pyvista.DataSet`]
Sequence of datasets. Can be of any :class:`pyvista.DataSet`.
merge_points : bool, default: True
Merge equivalent points when ``True``.
main_has_priority : bool, default: True
When this parameter is ``True`` and ``merge_points=True``, the arrays
of the merging grids will be overwritten by the original main mesh.
.. deprecated:: 0.46
This keyword will be removed in a future version. The main mesh
always has priority with VTK 9.5.0 or later.
progress_bar : bool, default: False
Display a progress bar to indicate progress.
Returns
-------
pyvista.DataSet
:class:`pyvista.PolyData` if all items in datasets are
:class:`pyvista.PolyData`, otherwise returns a
:class:`pyvista.UnstructuredGrid`.
Examples
--------
Merge two polydata datasets.
>>> import pyvista as pv
>>> sphere = pv.Sphere(center=(0, 0, 1))
>>> cube = pv.Cube()
>>> mesh = pv.merge([cube, sphere])
>>> mesh.plot()
pyvista.misc
Python Library Documentation: module pyvista.core.utilities.misc in pyvista.core.utilities
NAME
pyvista.core.utilities.misc - Miscellaneous core utilities.
CLASSES
builtins.int(builtins.object)
AnnotatedIntEnum(builtins.int, enum.Enum)
builtins.object
conditional_decorator
enum.Enum(builtins.object)
AnnotatedIntEnum(builtins.int, enum.Enum)
class AnnotatedIntEnum(builtins.int, enum.Enum)
| AnnotatedIntEnum(new_class_name, /, names, *, module=None, qualname=None, type=None, start=1, boundary=None)
|
| Annotated enum type.
|
| Method resolution order:
| AnnotatedIntEnum
| builtins.int
| enum.Enum
| builtins.object
|
| Methods defined here:
|
| __format__(self, format_spec) from enum.Enum
| Default object formatter.
|
| Return str(self) if format_spec is empty. Raise TypeError otherwise.
|
| __new__(cls, value) from enum.Enum
| Create and return a new object. See help(type) for accurate signature.
|
| __repr__(self) from enum.Enum
| Return repr(self).
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.int:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __and__(self, value, /)
| Return self&value.
|
| __bool__(self, /)
| True if self else False
|
| __ceil__(...)
| Ceiling of an Integral returns itself.
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __eq__(self, value, /)
| Return self==value.
|
| __float__(self, /)
| float(self)
|
| __floor__(...)
| Flooring an Integral returns itself.
|
| __floordiv__(self, value, /)
| Return self//value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __index__(self, /)
| Return self converted to an integer, if self is suitable for use as an index into a list.
|
| __int__(self, /)
| int(self)
|
| __invert__(self, /)
| ~self
|
| __le__(self, value, /)
| Return self<=value.
|
| __lshift__(self, value, /)
| Return self<<value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __mod__(self, value, /)
| Return self%value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __neg__(self, /)
| -self
|
| __or__(self, value, /)
| Return self|value.
|
| __pos__(self, /)
| +self
|
| __pow__(self, value, mod=None, /)
| Return pow(self, value, mod).
|
| __radd__(self, value, /)
| Return value+self.
|
| __rand__(self, value, /)
| Return value&self.
|
| __rdivmod__(self, value, /)
| Return divmod(value, self).
|
| __rfloordiv__(self, value, /)
| Return value//self.
|
| __rlshift__(self, value, /)
| Return value<<self.
|
| __rmod__(self, value, /)
| Return value%self.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __ror__(self, value, /)
| Return value|self.
|
| __round__(...)
| Rounding an Integral returns itself.
|
| Rounding with an ndigits argument also returns an integer.
|
| __rpow__(self, value, mod=None, /)
| Return pow(value, self, mod).
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| __rsub__(self, value, /)
| Return value-self.
|
| __rtruediv__(self, value, /)
| Return value/self.
|
| __rxor__(self, value, /)
| Return value^self.
|
| __sizeof__(self, /)
| Returns size in memory, in bytes.
|
| __sub__(self, value, /)
| Return self-value.
|
| __truediv__(self, value, /)
| Return self/value.
|
| __trunc__(...)
| Truncating an Integral returns itself.
|
| __xor__(self, value, /)
| Return self^value.
|
| as_integer_ratio(self, /)
| Return a pair of integers, whose ratio is equal to the original int.
|
| The ratio is in lowest terms and has a positive denominator.
|
| >>> (10).as_integer_ratio()
| (10, 1)
| >>> (-10).as_integer_ratio()
| (-10, 1)
| >>> (0).as_integer_ratio()
| (0, 1)
|
| bit_count(self, /)
| Number of ones in the binary representation of the absolute value of self.
|
| Also known as the population count.
|
| >>> bin(13)
| '0b1101'
| >>> (13).bit_count()
| 3
|
| bit_length(self, /)
| Number of bits necessary to represent self in binary.
|
| >>> bin(37)
| '0b100101'
| >>> (37).bit_length()
| 6
|
| conjugate(...)
| Returns self, the complex conjugate of any int.
|
| is_integer(self, /)
| Returns True. Exists for duck type compatibility with float.is_integer.
|
| to_bytes(self, /, length=1, byteorder='big', *, signed=False)
| Return an array of bytes representing an integer.
|
| length
| Length of bytes object to use. An OverflowError is raised if the
| integer is not representable with the given number of bytes. Default
| is length 1.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| `sys.byteorder' as the byte order value. Default is to use 'big'.
| signed
| Determines whether two's complement is used to represent the integer.
| If signed is False and a negative integer is given, an OverflowError
| is raised.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.int:
|
| from_bytes(bytes, byteorder='big', *, signed=False)
| Return the integer represented by the given array of bytes.
|
| bytes
| Holds the array of bytes to convert. The argument must either
| support the buffer protocol or be an iterable object producing bytes.
| Bytes and bytearray are examples of built-in objects that support the
| buffer protocol.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| `sys.byteorder' as the byte order value. Default is to use 'big'.
| signed
| Indicates whether two's complement is used to represent the integer.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.int:
|
| denominator
| the denominator of a rational number in lowest terms
|
| imag
| the imaginary part of a complex number
|
| numerator
| the numerator of a rational number in lowest terms
|
| real
| the real part of a complex number
|
| ----------------------------------------------------------------------
| Methods inherited from enum.Enum:
|
| __dir__(self)
| Returns public methods and other interesting attributes.
|
| __init__(self, *args, **kwds)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce_ex__(self, proto)
| Helper for pickle.
|
| __str__(self)
| Return str(self).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from enum.Enum:
|
| name
| The name of the Enum member.
|
| value
| The value of the Enum member.
|
| ----------------------------------------------------------------------
| Static methods inherited from enum.EnumType:
|
| __contains__(value)
| Return True if `value` is in `cls`.
|
| `value` is in `cls` if:
| 1) `value` is a member of `cls`, or
| 2) `value` is the value of one of the `cls`'s members.
|
| __getitem__(name)
| Return the member matching `name`.
|
| __iter__()
| Return members in definition order.
|
| __len__()
| Return the number of members (no aliases)
|
| ----------------------------------------------------------------------
| Readonly properties inherited from enum.EnumType:
|
| __members__
| Returns a mapping of member name->value.
|
| This mapping lists all enum members, including aliases. Note that this
| is a read-only view of the internal mapping.
class conditional_decorator(builtins.object)
| conditional_decorator(dec, condition) -> 'None'
|
| Conditional decorator for methods.
|
| Parameters
| ----------
| dec : callable
| The decorator to be applied conditionally.
| condition : bool
| Condition to match. If ``True``, the decorator is applied. If
| ``False``, the function is returned unchanged.
|
| Methods defined here:
|
| __call__(self, func)
| Call the decorated function if condition is matched.
|
| __init__(self, dec, condition) -> 'None'
| Initialize.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
abstract_class(cls_)
Decorate a class, overriding __new__.
Preventing a class from being instantiated similar to abc.ABCMeta
but does not require an abstract method.
Parameters
----------
cls_ : type
The class to be decorated as abstract.
assert_empty_kwargs(**kwargs) -> 'bool'
Assert that all keyword arguments have been used (internal helper).
If any keyword arguments are passed, a ``TypeError`` is raised.
Parameters
----------
**kwargs : dict
Keyword arguments passed to the function.
Returns
-------
bool
``True`` when successful.
Raises
------
TypeError
If any keyword arguments are passed, a ``TypeError`` is raised.
check_valid_vector(point: 'VectorLike[float]', name: 'str' = '') -> 'None'
Check if a vector contains three components.
Parameters
----------
point : VectorLike[float]
Input vector to check. Must be an iterable with exactly three components.
name : str, optional
Name to use in the error messages. If not provided, "Vector" will be used.
Raises
------
TypeError
If the input is not an iterable.
ValueError
If the input does not have exactly three components.
enable_smp_tools(backend: '_SMPBackendOptions' = 'stdthread', n_threads: 'int | None' = None) -> '_SMPToolsContext'
Enable a VTK SMP backend for filters that support shared-memory parallelism.
VTK's Python wheels currently default to the sequential SMP backend. This
helper switches to a parallel backend and optionally configures the maximum
number of threads used by VTK filters that rely on :vtk:`vtkSMPTools`.
The backend is applied immediately, so calling this function by itself
enables the chosen backend for the rest of the process. The return value is
also a context manager, so using it with a ``with`` statement will restore
the previous backend and thread count on exit.
Parameters
----------
backend : str, default: 'stdthread'
SMP backend to enable. Acceptable values are:
- ``'stdthread'``: Enable VTK's ``std::thread`` backend. This is the
default and is available in the current VTK wheels.
- ``'tbb'``: Enable Intel oneTBB when available in the current VTK
build.
- ``'openmp'``: Enable OpenMP when available in the current VTK build.
- ``'sequential'``: Use VTK's sequential backend.
n_threads : int, optional
Maximum number of threads to use. If not provided, VTK resets to its
default maximum thread count and honors the ``VTK_SMP_MAX_THREADS``
environment variable when it is set.
Returns
-------
contextlib.AbstractContextManager
A context manager that restores the previous SMP backend and thread
count when exited. The return value may be discarded when the change
should apply for the remainder of the process.
Raises
------
TypeError
If ``backend`` is not a string or if ``n_threads`` is not an integer.
ValueError
If ``backend`` is invalid or if ``n_threads`` is less than ``1``.
RuntimeError
If this VTK build does not support runtime SMP backend selection, or if
the requested backend is unavailable.
Examples
--------
Enable the wheel-supported ``stdthread`` backend for the rest of the
process.
>>> import pyvista as pv
>>> pv.enable_smp_tools() # doctest:+SKIP
Configure the backend before running a contour filter.
>>> from pyvista import examples
>>> pv.enable_smp_tools(n_threads=8) # doctest:+SKIP
>>> grid = examples.download_fea_bracket() # doctest:+SKIP
>>> _ = grid.contour(5, scalars='Equivalent Stress') # doctest:+SKIP
Scope the backend change to a ``with`` block. The previous backend and
thread count are restored on exit, even if an exception is raised.
>>> with pv.enable_smp_tools(n_threads=8): # doctest:+SKIP
... _ = grid.contour(5, scalars='Equivalent Stress')
has_module(module_name: 'str') -> 'bool'
Return if a module can be imported.
Parameters
----------
module_name : str
Name of the module to check.
Returns
-------
bool
``True`` if the module can be imported, otherwise ``False``.
set_new_attribute(obj: 'object', name: 'str', value: 'Any') -> 'None'
Set a new attribute for this object.
Python allows arbitrarily setting new attributes on objects at any time,
but PyVista's classes do not allow this. If an attribute is not part of
PyVista's API, an ``AttributeError`` is normally raised when attempting
to set it.
Use :func:`set_new_attribute` to override this and set a new attribute anyway.
See Also
--------
pyvista.allow_new_attributes
Context manager for controlling if setting new attributes is allowed.
Examples
--------
Set a new custom attribute on a mesh.
>>> import pyvista as pv
>>> mesh = pv.PolyData()
>>> pv.set_new_attribute(mesh, 'foo', 42)
>>> mesh.foo
42
This is equivalent to using :data:`allow_new_attributes` with ``True``.
>>> with pv.allow_new_attributes(True):
... mesh.foo = 42
.. versionadded:: 0.46
threaded(fn)
Call a function using a thread.
Parameters
----------
fn : callable
Callable object.
Returns
-------
function
Wrapped function.
try_callback(func, *args) -> 'None'
Wrap a given callback in a try statement.
Parameters
----------
func : callable
Callable object.
*args
Any arguments.
DATA
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
Self = typing.Self
Used to spell the type of "self" in classes.
Example::
from typing import Self
class Foo:
def return_self(self) -> Self:
...
return self
This is especially useful for:
- classmethods that are used as alternative constructors
- annotating an `__enter__` method which returns self
T = ~T
TYPE_CHECKING = False
__annotations__ = {'_SMP_BACKEND_NAMES': 'dict[str, str]'}
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\misc.py
pyvista.ncells_from_cells
Python Library Documentation: function ncells_from_cells in module pyvista.core.utilities.cells
ncells_from_cells(cells: 'NumpyArray[int]') -> 'int'
Get the number of cells from a VTK cell connectivity array.
Parameters
----------
cells : numpy.ndarray
A VTK cell connectivity array.
Returns
-------
int
The number of cells extracted from the given cell connectivity array.
pyvista.numpy_to_idarr
Python Library Documentation: function numpy_to_idarr in module pyvista.core.utilities.cells
numpy_to_idarr(ind: 'int | ArrayLike[int]', deep: 'bool' = False, return_ind: 'bool' = False) -> 'tuple[_vtk.vtkIdTypeArray, NumpyArray[int]] | _vtk.vtkIdTypeArray'
Safely convert a numpy array to a :vtk:`vtkIdTypeArray`.
Parameters
----------
ind : sequence[int]
Input sequence to be converted to a :vtk:`vtkIdTypeArray`. Can be
either a mask or an integer array-like.
deep : bool, default: False
If ``True``, deep copy the input data. If ``False``, do not deep copy
the input data.
return_ind : bool, default: False
If ``True``, also return the input array after it has been cast to the
proper dtype.
Returns
-------
:vtk:`vtkIdTypeArray`
Converted array as a :vtk:`vtkIdTypeArray`.
numpy.ndarray
The input array after it has been cast to the proper dtype. Only
returned if `return_ind` is set to ``True``.
Raises
------
TypeError
If the input array is not a mask or an integer array-like.
pyvista.objects
Python Library Documentation: module pyvista.core.objects in pyvista.core
NAME
pyvista.core.objects - Wrappers for :vtk:`vtkDataObject`.
DESCRIPTION
The data objects does not have any sort of spatial reference.
CLASSES
pyvista.core.dataobject.DataObject(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride)
Table(pyvista.core.dataobject.DataObject, vtkmodules.vtkCommonDataModel.vtkTable)
vtkmodules.vtkCommonDataModel.vtkTable(vtkmodules.vtkCommonDataModel.vtkDataObject)
Table(pyvista.core.dataobject.DataObject, vtkmodules.vtkCommonDataModel.vtkTable)
class Table(pyvista.core.dataobject.DataObject, vtkmodules.vtkCommonDataModel.vtkTable)
| Table(*args, **kwargs) -> '_T'
|
| Wrapper for the :vtk:`vtkTable` class.
|
| Create by passing a 2D NumPy array of shape (``n_rows`` by ``n_columns``)
| or from a dictionary containing NumPy arrays.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> arrays = np.random.default_rng().random((100, 3))
| >>> table = pv.Table(arrays)
|
| Method resolution order:
| Table
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkTable
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __arrow_c_stream__(self, requested_schema: 'object | None' = None) -> 'object'
| Export via the Arrow PyCapsule interface.
|
| Implements `the Arrow PyCapsule interface
| <https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html>`_
| by delegating to :meth:`to_arrow`, so pandas, polars, DuckDB,
| ibis, narwhals, and other Arrow-aware consumers can ingest this
| table directly. Scalar 1D columns cross the boundary zero-copy.
|
| Requires :mod:`pyarrow`.
|
| __delitem__(self, name) -> 'None'
| Remove an array by the specified name.
|
| __getitem__(self, index)
| Search row data for an array.
|
| __init__(self, *args, deep: 'bool' = True, **kwargs)
| Initialize the table.
|
| __iter__(self)
| Return the iterator across all arrays.
|
| __repr__(self)
| Return the object representation.
|
| __setitem__(self, name, scalars) -> 'None'
| Add/set an array in the row_arrays.
|
| __str__(self)
| Return the object string representation.
|
| get(self, index)
| Get an array by its name.
|
| Parameters
| ----------
| index : int or str
| Index or name of the row.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| PyVista array.
|
| get_data_range(self, arr: 'str | None' = None, preference: 'FieldLiteral | RowLiteral' = 'row') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr : str, numpy.ndarray, optional
| The name of the array to get the range. If ``None``, the active scalar
| is used.
|
| preference : str, optional
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'row'`` or
| ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the array.
|
| items(self)
| Return the table items.
|
| Returns
| -------
| list
| List containing tuples pairs of the name and array of the table arrays.
|
| keys(self)
| Return the table keys.
|
| Returns
| -------
| list
| List of the array names of this table.
|
| pop(self, name)
| Pop off an array by the specified name.
|
| Parameters
| ----------
| name : int or str
| Index or name of the row array.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| PyVista array.
|
| save(self, *args, **kwargs)
| Save the table.
|
| to_arrow(self) -> 'pyarrow.Table'
| Return this table as a :class:`pyarrow.Table`.
|
| Each row array becomes a column with the same name and dtype.
|
| Requires :mod:`pyarrow`.
|
| Returns
| -------
| pyarrow.Table
| This table represented as an Arrow Table.
|
| Notes
| -----
| 1D contiguous numeric columns wrap the underlying VTK buffer
| zero-copy. Booleans, complex numbers, and strings go through
| pyvista's existing VTK conversion and are copied. Arrow buffers
| are immutable by contract, so consumers cannot mutate VTK memory
| through the returned table.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> table = pv.Table({'a': np.arange(3), 'b': np.array([0.5, 1.5, 2.5])})
| >>> table.to_arrow().schema.names
| ['a', 'b']
|
| to_pandas(self)
| Create a Pandas DataFrame from this Table.
|
| Returns
| -------
| pandas.DataFrame
| This table represented as a pandas dataframe.
|
| update(self, data) -> 'None'
| Set the table data using a dict-like update.
|
| Parameters
| ----------
| data : DataSetAttributes
| Other dataset attributes to update from.
|
| values(self)
| Return the table values.
|
| Returns
| -------
| list
| List of the table arrays.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| is_empty
| Return ``True`` if the table has no rows and no columns.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> table = pv.Table()
| >>> table.is_empty
| True
|
| >>> arrays = np.random.default_rng().random((100, 3))
| >>> table = pv.Table(arrays)
| >>> table.is_empty
| False
|
| n_arrays
| Return the number of columns.
|
| Alias for: ``n_columns``.
|
| Returns
| -------
| int
| The number of columns.
|
| n_columns
| Return the number of columns.
|
| Returns
| -------
| int
| The number of columns.
|
| row_arrays
| Return the all row arrays.
|
| Returns
| -------
| int
| The all row arrays.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| n_rows
| Return the number of rows.
|
| Returns
| -------
| int
| The number of rows.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_meta_from(self: 'Self', *args, **kwargs) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Intended to be overridden by subclasses.
|
| Parameters
| ----------
| *args : tuple
| Positional arguments.
|
| **kwargs : dict, optional
| Keyword arguments.
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkTable:
|
| AddColumn(...)
| AddColumn(self, arr:vtkAbstractArray) -> None
| C++: void AddColumn(vtkAbstractArray *arr)
|
| Add a column to the table.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| Dump(...)
| Dump(self, colWidth:int=16, rowLimit:int=-1, indent:int=0) -> None
| C++: void Dump(unsigned int colWidth=16, int rowLimit=-1,
| unsigned int indent=0)
|
| Dump table contents. If rowLimit is -1 then the full table is
| printed out (Default). If rowLimit is 0 then only the header row
| will be displayed. Otherwise, if rowLimit > 0 then Dump will
| print the first rowLimit rows of data.
|
| If indent is non-zero, the table will be printed with the given
| number of leading spaces.
|
| ExtendedNew(...)
| ExtendedNew() -> vtkTable
| C++: static vtkTable *ExtendedNew()
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated. The
| memory size returned is guaranteed to be greater than or equal to
| the memory required to represent the data (e.g., extra space in
| arrays, etc. are not included in the return value).
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetColumn(...)
| GetColumn(self, col:int) -> vtkAbstractArray
| C++: vtkAbstractArray *GetColumn(vtkIdType col)
|
| Get a column of the table by its column index.
|
| GetColumnByName(...)
| GetColumnByName(self, name:str) -> vtkAbstractArray
| C++: vtkAbstractArray *GetColumnByName(const char *name)
|
| Get a column of the table by its name.
|
| GetColumnIndex(...)
| GetColumnIndex(self, name:str) -> int
| C++: vtkIdType GetColumnIndex(const char *name)
|
| Get the column index for a name. If name is not found returns -1.
|
| GetColumnName(...)
| GetColumnName(self, col:int) -> str
| C++: const char *GetColumnName(vtkIdType col)
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkTable
| C++: static vtkTable *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkTable
| C++: static vtkTable *GetData(vtkInformationVector *v, int i=0)
|
| Retrieve the table from vtkInformation.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return what type of dataset this is.
|
| GetNumberOfColumns(...)
| GetNumberOfColumns(self) -> int
| C++: vtkIdType GetNumberOfColumns()
|
| Get the number of columns in the table.
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (ROW,
| etc.).
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfRows(...)
| GetNumberOfRows(self) -> int
| C++: vtkIdType GetNumberOfRows()
|
| Get the number of rows in the table.
|
| GetRow(...)
| GetRow(self, row:int) -> vtkVariantArray
| C++: vtkVariantArray *GetRow(vtkIdType row)
| GetRow(self, row:int, values:vtkVariantArray) -> None
| C++: void GetRow(vtkIdType row, vtkVariantArray *values)
|
| Get a row of the table as a vtkVariantArray which has one entry
| for each column. NOTE: This version of the method is NOT thread
| safe.
|
| GetRowData(...)
| GetRowData(self) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetRowData()
|
| Get/Set the main data (columns) of the table.
|
| GetValue(...)
| GetValue(self, row:int, col:int) -> vtkVariant
| C++: vtkVariant GetValue(vtkIdType row, vtkIdType col)
|
| Retrieve a value in the table by row and column index as a
| variant. Note that this calls GetValueByName internally so that
| each column array must have its name set (and that name should be
| unique within the table).
|
| GetValueByName(...)
| GetValueByName(self, row:int, col:str) -> vtkVariant
| C++: vtkVariant GetValueByName(vtkIdType row, const char *col)
|
| Retrieve a value in the table by row index and column name as a
| variant.
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Initialize to an empty table.
|
| InsertColumn(...)
| InsertColumn(self, arr:vtkAbstractArray, index:int) -> None
| C++: void InsertColumn(vtkAbstractArray *arr, vtkIdType index)
|
| Insert a column into the table at given column index.
|
| InsertNextBlankRow(...)
| InsertNextBlankRow(self, default_num_val:float=0.0) -> int
| C++: vtkIdType InsertNextBlankRow(double default_num_val=0.0)
|
| Insert a blank row at the end of the table.
|
| InsertNextRow(...)
| InsertNextRow(self, values:vtkVariantArray) -> int
| C++: vtkIdType InsertNextRow(vtkVariantArray *values)
|
| Insert a row at the end of the tablespecified by a
| vtkVariantArray. The number of entries in the array should match
| the number of columns in the table.
|
| InsertRow(...)
| InsertRow(self, row:int) -> None
| C++: void InsertRow(vtkIdType row)
|
| Insert a single row at the index.
|
| InsertRows(...)
| InsertRows(self, row:int, n:int) -> None
| C++: void InsertRows(vtkIdType row, vtkIdType n)
|
| Insert n rows before row. If row < 0 then the rows will be
| prepended to the table.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkTable
| C++: vtkTable *NewInstance()
|
| RemoveAllColumns(...)
| RemoveAllColumns(self) -> None
| C++: void RemoveAllColumns()
|
| Remove all columns from the table.
|
| RemoveAllRows(...)
| RemoveAllRows(self) -> None
| C++: void RemoveAllRows()
|
| Delete all rows from the table. The column arrays are not delete,
| they are just empty after this operation.
|
| RemoveColumn(...)
| RemoveColumn(self, col:int) -> None
| C++: void RemoveColumn(vtkIdType col)
|
| Remove a column from the table by its column index.
|
| RemoveColumnByName(...)
| RemoveColumnByName(self, name:str) -> None
| C++: void RemoveColumnByName(const char *name)
|
| Remove a column from the table by its name.
|
| RemoveRow(...)
| RemoveRow(self, row:int) -> None
| C++: void RemoveRow(vtkIdType row)
|
| Delete a single row from the table. Rows below the deleted row
| are shifted up.
|
| RemoveRows(...)
| RemoveRows(self, row:int, n:int) -> None
| C++: void RemoveRows(vtkIdType row, vtkIdType n)
|
| Delete n rows from the table, starting at row. Rows below the
| deleted rows are shifted up.
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkTable
| C++: static vtkTable *SafeDownCast(vtkObjectBase *o)
|
| SetNumberOfRows(...)
| SetNumberOfRows(self, __a:int) -> None
| C++: void SetNumberOfRows(vtkIdType)
|
| Set the number of rows in the table. Note that memory allocation
| might be performed as a result of this, but no memory will be
| released. Existing data is preserved if the table is expanding.
|
| SetRow(...)
| SetRow(self, row:int, values:vtkVariantArray) -> None
| C++: void SetRow(vtkIdType row, vtkVariantArray *values)
|
| Set a row of the table with a vtkVariantArray which has one entry
| for each column.
|
| SetRowData(...)
| SetRowData(self, data:vtkDataSetAttributes) -> None
| C++: virtual void SetRowData(vtkDataSetAttributes *data)
|
| SetValue(...)
| SetValue(self, row:int, col:int, value:vtkVariant) -> None
| C++: void SetValue(vtkIdType row, vtkIdType col, vtkVariant value)
|
| Set a value in the table by row and column index as a variant.
|
| SetValueByName(...)
| SetValueByName(self, row:int, col:str, value:vtkVariant) -> None
| C++: void SetValueByName(vtkIdType row, const char *col,
| vtkVariant value)
|
| Set a value in the table by row index and column name as a
| variant.
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow/deep copy the data from src into this object.
|
| SqueezeRows(...)
| SqueezeRows(self) -> None
| C++: void SqueezeRows()
|
| Release previously allocated and now unused memory after
| performing resizing operations.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkTable:
|
| __this__
| Pointer to the C++ object.
|
| data_object_type
| read-only, calls GetDataObjectType
|
| number_of_columns
| read-only, calls GetNumberOfColumns
|
| number_of_rows
| read-write, calls GetNumberOfRows/SetNumberOfRows
|
| row_data
| read-write, calls GetRowData/SetRowData
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkTable:
|
| __vtkname__ = 'vtkTable'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: virtual void Crop(const int *updateExtent)
|
| This method crops the data object (if necessary) so that the
| extent matches the update extent.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: virtual int GetExtentType()
|
| The ExtentType will be left as VTK_PIECES_EXTENT for data objects
| such as vtkPolyData and vtkUnstructuredGrid. The ExtentType will
| be changed to VTK_3D_EXTENT for data objects with 3D structure
| such as vtkImageData (and its subclass vtkStructuredPoints),
| vtkRectilinearGrid, and vtkStructuredGrid. The default is the
| have an extent in pieces, with only one piece (no streaming
| possible).
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: virtual vtkUnsignedCharArray *GetGhostArray(int type)
|
| Returns the ghost arrays of the data object of the specified
| attribute type. The type may be: POINT - Defined in
| vtkDataSet subclasses CELL - Defined in vtkDataSet subclasses.
| The other attribute types, will return nullptr since ghosts
| arrays are not defined for now outside of point or cell.
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Data objects are composite objects and need to check each part
| for MTime. The information object also needs to be considered.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: virtual bool SupportsGhostArray(int type)
|
| Returns if this type of data object support ghost array for
| specified type. The type may be: POINT - Defined in
| vtkDataSet subclasses CELL - Defined in vtkDataSet subclasses.
| The other attribute types, will return false since ghosts arrays
| are not defined for now outside of point or cell. for
| vtkDataObject, this always return false but subclasses may
| override this method and implement their own logic.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| extent_type
| read-only, calls GetExtentType
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| m_time
| read-only, calls GetMTime
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
DATA
FieldLiteral = typing.Literal[<FieldAssociation.NONE: 2>, 'field']
RowLiteral = typing.Literal[<FieldAssociation.ROW: 6>, 'row']
TYPE_CHECKING = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\objects.py
pyvista.observers
Python Library Documentation: module pyvista.core.utilities.observers in pyvista.core.utilities
NAME
pyvista.core.utilities.observers - Core error utilities.
CLASSES
builtins.object
VtkErrorCatcher
builtins.tuple(builtins.object)
VtkEvent
pyvista.core.utilities.misc._NoNewAttrMixin(builtins.object)
Observer
ProgressMonitor
class Observer(pyvista.core.utilities.misc._NoNewAttrMixin)
| Observer(*args, **kwargs) -> '_T'
|
| A standard class for observing VTK objects.
|
| Method resolution order:
| Observer
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| __call__(self, _obj, _event, message) -> 'None'
| Declare standard call function for the observer.
|
| On an event occurrence, this function executes.
|
| __init__(self, event_type='ErrorEvent', log: 'bool' = True, store_history: 'bool' = False) -> 'None'
| Initialize observer.
|
| get_message(self, etc: 'bool' = False)
| Get the last set error message.
|
| Returns
| -------
| str
| The last set error message.
|
| has_event_occurred(self)
| Ask self if an error has occurred since last queried.
|
| This resets the observer's status.
|
| log_message(self, kind, alert) -> 'None'
| Parse different event types and passes them to logging.
|
| observe(self, algorithm)
| Make this an observer of an algorithm.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| parse_message(message) -> 'VtkEvent'
| Parse the given message.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class ProgressMonitor(pyvista.core.utilities.misc._NoNewAttrMixin)
| ProgressMonitor(*args, **kwargs) -> '_T'
|
| A standard class for monitoring the progress of a VTK algorithm.
|
| This must be use in a ``with`` context and it will block keyboard
| interrupts from happening until the exit event as interrupts will crash
| the kernel if the VTK algorithm is still executing.
|
| Parameters
| ----------
| algorithm
| VTK algorithm or filter.
|
| message : str, default: ""
| Message to display in the progress bar.
|
| Method resolution order:
| ProgressMonitor
| pyvista.core.utilities.misc._NoNewAttrMixin
| builtins.object
|
| Methods defined here:
|
| __call__(self, obj, *args) -> 'None'
| Call progress update callback.
|
| On an event occurrence, this function executes.
|
| __enter__(self)
| Enter event for ``with`` context.
|
| __exit__(self, *args) -> 'None'
| Exit event for ``with`` context.
|
| __init__(self, algorithm, message='')
| Initialize observer.
|
| handler(self, sig, frame) -> 'None'
| Pass signal to custom interrupt handler.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class VtkErrorCatcher(builtins.object)
| VtkErrorCatcher(raise_errors: 'bool' = False, send_to_logging: 'bool' = True, emit_warnings: 'bool' = False) -> 'None'
|
| Context manager to temporarily catch VTK errors.
|
| Parameters
| ----------
| raise_errors : bool, default: False
| Raise a ``pyvista.VTKExecutionError`` (a runtime error) when a VTK error
| is observed.
|
| .. versionchanged:: 0.47
|
| A ``pyvista.VTKExecutionError`` is now raised instead of a generic
| ``RuntimeError``.
|
| send_to_logging : bool, default: True
| Determine whether VTK errors raised within the context should
| also be sent to logging.
|
| emit_warnings : bool, default: False
| Emit a ``pyvista.VTKExecutionWarning`` (a runtime warning) when a VTK warning
| is observed.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| Catch VTK errors using the context manager. This only sends to
| logging by default.
|
| >>> import pyvista as pv
| >>> with pv.VtkErrorCatcher() as error_catcher:
| ... sphere = pv.Sphere()
|
| Raise VTK errors as Python errors and emit VTK warnings as Python warnings.
|
| >>> with pv.VtkErrorCatcher(
| ... raise_errors=True, emit_warnings=True
| ... ) as error_catcher:
| ... sphere = pv.Sphere()
|
| Methods defined here:
|
| __enter__(self: 'Self') -> 'Self'
| Observe VTK string output window for errors.
|
| __exit__(self, *args)
| Stop observing VTK string output window.
|
| __init__(self, raise_errors: 'bool' = False, send_to_logging: 'bool' = True, emit_warnings: 'bool' = False) -> 'None'
| Initialize context manager.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| error_events
| List of VTK error events observed.
|
| .. versionadded:: 0.47
|
| events
| List of all VTK warning and error events observed.
|
| .. versionadded:: 0.47
|
| warning_events
| List of VTK error events observed.
|
| .. versionadded:: 0.47
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class VtkEvent(builtins.tuple)
| VtkEvent(kind: ForwardRef('str'), path: ForwardRef('str'), address: ForwardRef('str'), alert: ForwardRef('str'), line: ForwardRef('str'), name: ForwardRef('str'))
|
| Named tuple to store VTK event information.
|
| Method resolution order:
| VtkEvent
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.VtkEvent
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.VtkEvent
| Return a nicely formatted representation string
|
| __str__(self)
| Return str(self).
|
| _asdict(self) from collections.VtkEvent
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.VtkEvent
| Return a new VtkEvent object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.VtkEvent
| Make a new VtkEvent object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, kind: ForwardRef('str'), path: ForwardRef('str'), address: ForwardRef('str'), alert: ForwardRef('str'), line: ForwardRef('str'), name: ForwardRef('str')) from namedtuple_VtkEvent.VtkEvent
| Create new instance of VtkEvent(kind, path, address, alert, line, name)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| kind
| Alias for field number 0
|
| path
| Alias for field number 1
|
| address
| Alias for field number 2
|
| alert
| Alias for field number 3
|
| line
| Alias for field number 4
|
| name
| Alias for field number 5
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'address': ForwardRef('str'), 'alert': ForwardRef('...
|
| __match_args__ = ('kind', 'path', 'address', 'alert', 'line', 'name')
|
| __orig_bases__ = (<function NamedTuple>,)
|
| _field_defaults = {}
|
| _fields = ('kind', 'path', 'address', 'alert', 'line', 'name')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
FUNCTIONS
send_errors_to_logging()
Send all VTK error/warning messages to Python's logging module.
set_error_output_file(filename)
Set a file to write out the VTK errors.
Parameters
----------
filename : str, Path
Path to the file to write VTK errors to.
Returns
-------
:vtk:`vtkFileOutputWindow`
VTK file output window.
:vtk:`vtkOutputWindow`
VTK output window.
DATA
TYPE_CHECKING = False
log = <Logger pyvista.core.utilities.observers (WARNING)>
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\observers.py
pyvista.os
Python Library Documentation: module os
NAME
os - OS routines for NT or Posix depending on what system we're on.
MODULE REFERENCE
https://docs.python.org/3.12/library/os.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
DESCRIPTION
This exports:
- all functions from posix or nt, e.g. unlink, stat, etc.
- os.path is either posixpath or ntpath
- os.name is either 'posix' or 'nt'
- os.curdir is a string representing the current directory (always '.')
- os.pardir is a string representing the parent directory (always '..')
- os.sep is the (or a most common) pathname separator ('/' or '\\')
- os.extsep is the extension separator (always '.')
- os.altsep is the alternate pathname separator (None or '/')
- os.pathsep is the component separator used in $PATH etc
- os.linesep is the line separator in text files ('\r' or '\n' or '\r\n')
- os.defpath is the default search path for executables
- os.devnull is the file path of the null device ('/dev/null', etc.)
Programs that import and use 'os' stand a better chance of being
portable between different platforms. Of course, they must then
only use functions that are defined by all platforms (e.g., unlink
and opendir), and leave all pathname manipulation to os.path
(e.g., split and join).
CLASSES
builtins.Exception(builtins.BaseException)
builtins.OSError
builtins.object
nt.DirEntry
builtins.tuple(builtins.object)
nt.times_result
nt.uname_result
stat_result
statvfs_result
terminal_size
class DirEntry(builtins.object)
| Methods defined here:
|
| __fspath__(self, /)
| Returns the path for the entry.
|
| __repr__(self, /)
| Return repr(self).
|
| inode(self, /)
| Return inode of the entry; cached per entry.
|
| is_dir(self, /, *, follow_symlinks=True)
| Return True if the entry is a directory; cached per entry.
|
| is_file(self, /, *, follow_symlinks=True)
| Return True if the entry is a file; cached per entry.
|
| is_junction(self, /)
| Return True if the entry is a junction; cached per entry.
|
| is_symlink(self, /)
| Return True if the entry is a symbolic link; cached per entry.
|
| stat(self, /, *, follow_symlinks=True)
| Return stat_result object for the entry; cached per entry.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...)
| See PEP 585
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| name
| the entry's base filename, relative to scandir() "path" argument
|
| path
| the entry's full path name; equivalent to os.path.join(scandir_path, entry.name)
error = class OSError(Exception)
| Base class for I/O related errors.
|
| Method resolution order:
| OSError
| Exception
| BaseException
| object
|
| Built-in subclasses:
| BlockingIOError
| ChildProcessError
| ConnectionError
| FileExistsError
| ... and 7 other subclasses
|
| Methods defined here:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce__(...)
| Helper for pickle.
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| characters_written
|
| errno
| POSIX exception code
|
| filename
| exception filename
|
| filename2
| second exception filename
|
| strerror
| exception strerror
|
| winerror
| Win32 exception code
|
| ----------------------------------------------------------------------
| Methods inherited from BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class stat_result(builtins.tuple)
| stat_result(iterable=(), /)
|
| stat_result: Result from stat, fstat, or lstat.
|
| This object may be accessed either as a tuple of
| (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)
| or via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.
|
| Posix/windows: If your platform supports st_blksize, st_blocks, st_rdev,
| or st_flags, they are available as attributes only.
|
| See os.stat for more information.
|
| Method resolution order:
| stat_result
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| st_atime
| time of last access
|
| st_atime_ns
| time of last access in nanoseconds
|
| st_birthtime
| time of creation
|
| st_birthtime_ns
| time of creation in nanoseconds
|
| st_ctime
| time of last change
|
| st_ctime_ns
| time of last change in nanoseconds
|
| st_dev
| device
|
| st_file_attributes
| Windows file attribute bits
|
| st_gid
| group ID of owner
|
| st_ino
| inode
|
| st_mode
| protection bits
|
| st_mtime
| time of last modification
|
| st_mtime_ns
| time of last modification in nanoseconds
|
| st_nlink
| number of hard links
|
| st_reparse_tag
| Windows reparse tag
|
| st_size
| total size, in bytes
|
| st_uid
| user ID of owner
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __match_args__ = ('st_mode', 'st_ino', 'st_dev', 'st_nlink', 'st_uid',...
|
| n_fields = 20
|
| n_sequence_fields = 10
|
| n_unnamed_fields = 3
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class statvfs_result(builtins.tuple)
| statvfs_result(iterable=(), /)
|
| statvfs_result: Result from statvfs or fstatvfs.
|
| This object may be accessed either as a tuple of
| (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),
| or via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.
|
| See os.statvfs for more information.
|
| Method resolution order:
| statvfs_result
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| f_bavail
|
| f_bfree
|
| f_blocks
|
| f_bsize
|
| f_favail
|
| f_ffree
|
| f_files
|
| f_flag
|
| f_frsize
|
| f_fsid
|
| f_namemax
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __match_args__ = ('f_bsize', 'f_frsize', 'f_blocks', 'f_bfree', 'f_bav...
|
| n_fields = 11
|
| n_sequence_fields = 10
|
| n_unnamed_fields = 0
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class terminal_size(builtins.tuple)
| terminal_size(iterable=(), /)
|
| A tuple of (columns, lines) for holding terminal window size
|
| Method resolution order:
| terminal_size
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| columns
| width of the terminal window in characters
|
| lines
| height of the terminal window in characters
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __match_args__ = ('columns', 'lines')
|
| n_fields = 2
|
| n_sequence_fields = 2
|
| n_unnamed_fields = 0
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class times_result(builtins.tuple)
| times_result(iterable=(), /)
|
| times_result: Result from os.times().
|
| This object may be accessed either as a tuple of
| (user, system, children_user, children_system, elapsed),
| or via the attributes user, system, children_user, children_system,
| and elapsed.
|
| See os.times for more information.
|
| Method resolution order:
| times_result
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| children_system
| system time of children
|
| children_user
| user time of children
|
| elapsed
| elapsed time since an arbitrary point in the past
|
| system
| system time
|
| user
| user time
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __match_args__ = ('user', 'system', 'children_user', 'children_system'...
|
| n_fields = 5
|
| n_sequence_fields = 5
|
| n_unnamed_fields = 0
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class uname_result(builtins.tuple)
| uname_result(iterable=(), /)
|
| uname_result: Result from os.uname().
|
| This object may be accessed either as a tuple of
| (sysname, nodename, release, version, machine),
| or via the attributes sysname, nodename, release, version, and machine.
|
| See os.uname for more information.
|
| Method resolution order:
| uname_result
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| machine
| hardware identifier
|
| nodename
| name of machine on network (implementation-defined)
|
| release
| operating system release
|
| sysname
| operating system name
|
| version
| operating system version
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __match_args__ = ('sysname', 'nodename', 'release', 'version', 'machin...
|
| n_fields = 5
|
| n_sequence_fields = 5
|
| n_unnamed_fields = 0
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
FUNCTIONS
_exit(status)
Exit to the system with specified status, without normal exit processing.
abort()
Abort the interpreter immediately.
This function 'dumps core' or otherwise fails in the hardest way possible
on the hosting operating system. This function never returns.
access(path, mode, *, dir_fd=None, effective_ids=False, follow_symlinks=True)
Use the real uid/gid to test for access to a path.
path
Path to be tested; can be string, bytes, or a path-like object.
mode
Operating-system mode bitfield. Can be F_OK to test existence,
or the inclusive-OR of R_OK, W_OK, and X_OK.
dir_fd
If not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that
directory.
effective_ids
If True, access will use the effective uid/gid instead of
the real uid/gid.
follow_symlinks
If False, and the last element of the path is a symbolic link,
access will examine the symbolic link itself instead of the file
the link points to.
dir_fd, effective_ids, and follow_symlinks may not be implemented
on your platform. If they are unavailable, using them will raise a
NotImplementedError.
Note that most operations will use the effective uid/gid, therefore this
routine can be used in a suid/sgid environment to test if the invoking user
has the specified access to the path.
chdir(path)
Change the current working directory to the specified path.
path may always be specified as a string.
On some platforms, path may also be specified as an open file descriptor.
If this functionality is unavailable, using it raises an exception.
chmod(path, mode, *, dir_fd=None, follow_symlinks=True)
Change the access permissions of a file.
path
Path to be modified. May always be specified as a str, bytes, or a path-like object.
On some platforms, path may also be specified as an open file descriptor.
If this functionality is unavailable, using it raises an exception.
mode
Operating-system mode bitfield.
Be careful when using number literals for *mode*. The conventional UNIX notation for
numeric modes uses an octal base, which needs to be indicated with a ``0o`` prefix in
Python.
dir_fd
If not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that
directory.
follow_symlinks
If False, and the last element of the path is a symbolic link,
chmod will modify the symbolic link itself instead of the file
the link points to.
It is an error to use dir_fd or follow_symlinks when specifying path as
an open file descriptor.
dir_fd and follow_symlinks may not be implemented on your platform.
If they are unavailable, using them will raise a NotImplementedError.
close(fd)
Close a file descriptor.
closerange(fd_low, fd_high, /)
Closes all file descriptors in [fd_low, fd_high), ignoring errors.
cpu_count()
Return the number of CPUs in the system; return None if indeterminable.
This number is not equivalent to the number of CPUs the current process can
use. The number of usable CPUs can be obtained with
``len(os.sched_getaffinity(0))``
device_encoding(fd)
Return a string describing the encoding of a terminal's file descriptor.
The file descriptor must be attached to a terminal.
If the device is not a terminal, return None.
dup(fd, /)
Return a duplicate of a file descriptor.
dup2(fd, fd2, inheritable=True)
Duplicate file descriptor.
execl(file, *args)
execl(file, *args)
Execute the executable file with argument list args, replacing the
current process.
execle(file, *args)
execle(file, *args, env)
Execute the executable file with argument list args and
environment env, replacing the current process.
execlp(file, *args)
execlp(file, *args)
Execute the executable file (which is searched for along $PATH)
with argument list args, replacing the current process.
execlpe(file, *args)
execlpe(file, *args, env)
Execute the executable file (which is searched for along $PATH)
with argument list args and environment env, replacing the current
process.
execv(path, argv, /)
Execute an executable path with arguments, replacing current process.
path
Path of executable file.
argv
Tuple or list of strings.
execve(path, argv, env)
Execute an executable path with arguments, replacing current process.
path
Path of executable file.
argv
Tuple or list of strings.
env
Dictionary of strings mapping to strings.
execvp(file, args)
execvp(file, args)
Execute the executable file (which is searched for along $PATH)
with argument list args, replacing the current process.
args may be a list or tuple of strings.
execvpe(file, args, env)
execvpe(file, args, env)
Execute the executable file (which is searched for along $PATH)
with argument list args and environment env, replacing the
current process.
args may be a list or tuple of strings.
fdopen(fd, mode='r', buffering=-1, encoding=None, *args, **kwargs)
fsdecode(filename)
Decode filename (an os.PathLike, bytes, or str) from the filesystem
encoding with 'surrogateescape' error handler, return str unchanged. On
Windows, use 'strict' error handler if the file system encoding is
'mbcs' (which is the default encoding).
fsencode(filename)
Encode filename (an os.PathLike, bytes, or str) to the filesystem
encoding with 'surrogateescape' error handler, return bytes unchanged.
On Windows, use 'strict' error handler if the file system encoding is
'mbcs' (which is the default encoding).
fspath(path)
Return the file system path representation of the object.
If the object is str or bytes, then allow it to pass through as-is. If the
object defines __fspath__(), then return the result of that method. All other
types raise a TypeError.
fstat(fd)
Perform a stat system call on the given file descriptor.
Like stat(), but for an open file descriptor.
Equivalent to os.stat(fd).
fsync(fd)
Force write of fd to disk.
ftruncate(fd, length, /)
Truncate a file, specified by file descriptor, to a specific length.
get_blocking(fd, /)
Get the blocking mode of the file descriptor.
Return False if the O_NONBLOCK flag is set, True if the flag is cleared.
get_exec_path(env=None)
Returns the sequence of directories that will be searched for the
named executable (similar to a shell) when launching a process.
*env* must be an environment variable dict or None. If *env* is None,
os.environ will be used.
get_handle_inheritable(handle, /)
Get the close-on-exe flag of the specified file descriptor.
get_inheritable(fd, /)
Get the close-on-exe flag of the specified file descriptor.
get_terminal_size(...)
Return the size of the terminal window as (columns, lines).
The optional argument fd (default standard output) specifies
which file descriptor should be queried.
If the file descriptor is not connected to a terminal, an OSError
is thrown.
This function will only be defined if an implementation is
available for this system.
shutil.get_terminal_size is the high-level function which should
normally be used, os.get_terminal_size is the low-level implementation.
getcwd()
Return a unicode string representing the current working directory.
getcwdb()
Return a bytes string representing the current working directory.
getenv(key, default=None)
Get an environment variable, return None if it doesn't exist.
The optional second argument can specify an alternate default.
key, default and the result are str.
getlogin()
Return the actual login name.
getpid()
Return the current process id.
getppid()
Return the parent's process id.
If the parent process has already exited, Windows machines will still
return its id; others systems will return the id of the 'init' process (1).
isatty(fd, /)
Return True if the fd is connected to a terminal.
Return True if the file descriptor is an open file descriptor
connected to the slave end of a terminal.
kill(pid, signal, /)
Kill a process with a signal.
link(src, dst, *, src_dir_fd=None, dst_dir_fd=None, follow_symlinks=True)
Create a hard link to a file.
If either src_dir_fd or dst_dir_fd is not None, it should be a file
descriptor open to a directory, and the respective path string (src or dst)
should be relative; the path will then be relative to that directory.
If follow_symlinks is False, and the last element of src is a symbolic
link, link will create a link to the symbolic link itself instead of the
file the link points to.
src_dir_fd, dst_dir_fd, and follow_symlinks may not be implemented on your
platform. If they are unavailable, using them will raise a
NotImplementedError.
listdir(path=None)
Return a list containing the names of the files in the directory.
path can be specified as either str, bytes, or a path-like object. If path is bytes,
the filenames returned will also be bytes; in all other circumstances
the filenames returned will be str.
If path is None, uses the path='.'.
On some platforms, path may also be specified as an open file descriptor;\
the file descriptor must refer to a directory.
If this functionality is unavailable, using it raises NotImplementedError.
The list is in arbitrary order. It does not include the special
entries '.' and '..' even if they are present in the directory.
listdrives()
Return a list containing the names of drives in the system.
A drive name typically looks like 'C:\\'.
listmounts(volume)
Return a list containing mount points for a particular volume.
'volume' should be a GUID path as returned from os.listvolumes.
listvolumes()
Return a list containing the volumes in the system.
Volumes are typically represented as a GUID path.
lseek(fd, position, whence, /)
Set the position of a file descriptor. Return the new position.
fd
An open file descriptor, as returned by os.open().
position
Position, interpreted relative to 'whence'.
whence
The relative position to seek from. Valid values are:
- SEEK_SET: seek from the start of the file.
- SEEK_CUR: seek from the current file position.
- SEEK_END: seek from the end of the file.
The return value is the number of bytes relative to the beginning of the file.
lstat(path, *, dir_fd=None)
Perform a stat system call on the given path, without following symbolic links.
Like stat(), but do not follow symbolic links.
Equivalent to stat(path, follow_symlinks=False).
makedirs(name, mode=511, exist_ok=False)
makedirs(name [, mode=0o777][, exist_ok=False])
Super-mkdir; create a leaf directory and all intermediate ones. Works like
mkdir, except that any intermediate path segment (not just the rightmost)
will be created if it does not exist. If the target directory already
exists, raise an OSError if exist_ok is False. Otherwise no exception is
raised. This is recursive.
mkdir(path, mode=511, *, dir_fd=None)
Create a directory.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError.
The mode argument is ignored on Windows. Where it is used, the current umask
value is first masked out.
open(path, flags, mode=511, *, dir_fd=None)
Open a file for low level IO. Returns a file descriptor (integer).
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError.
pipe()
Create a pipe.
Returns a tuple of two file descriptors:
(read_fd, write_fd)
popen(cmd, mode='r', buffering=-1)
putenv(name, value, /)
Change or add an environment variable.
read(fd, length, /)
Read from a file descriptor. Returns a bytes object.
readlink(path, *, dir_fd=None)
Return a string representing the path to which the symbolic link points.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform. If it is unavailable,
using it will raise a NotImplementedError.
remove(path, *, dir_fd=None)
Remove a file (same as unlink()).
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError.
removedirs(name)
removedirs(name)
Super-rmdir; remove a leaf directory and all empty intermediate
ones. Works like rmdir except that, if the leaf directory is
successfully removed, directories corresponding to rightmost path
segments will be pruned away until either the whole path is
consumed or an error occurs. Errors during this latter phase are
ignored -- they generally mean that a directory was not empty.
rename(src, dst, *, src_dir_fd=None, dst_dir_fd=None)
Rename a file or directory.
If either src_dir_fd or dst_dir_fd is not None, it should be a file
descriptor open to a directory, and the respective path string (src or dst)
should be relative; the path will then be relative to that directory.
src_dir_fd and dst_dir_fd, may not be implemented on your platform.
If they are unavailable, using them will raise a NotImplementedError.
renames(old, new)
renames(old, new)
Super-rename; create directories as necessary and delete any left
empty. Works like rename, except creation of any intermediate
directories needed to make the new pathname good is attempted
first. After the rename, directories corresponding to rightmost
path segments of the old name will be pruned until either the
whole path is consumed or a nonempty directory is found.
Note: this function can fail with the new directory structure made
if you lack permissions needed to unlink the leaf directory or
file.
replace(src, dst, *, src_dir_fd=None, dst_dir_fd=None)
Rename a file or directory, overwriting the destination.
If either src_dir_fd or dst_dir_fd is not None, it should be a file
descriptor open to a directory, and the respective path string (src or dst)
should be relative; the path will then be relative to that directory.
src_dir_fd and dst_dir_fd, may not be implemented on your platform.
If they are unavailable, using them will raise a NotImplementedError.
rmdir(path, *, dir_fd=None)
Remove a directory.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError.
scandir(path=None)
Return an iterator of DirEntry objects for given path.
path can be specified as either str, bytes, or a path-like object. If path
is bytes, the names of yielded DirEntry objects will also be bytes; in
all other circumstances they will be str.
If path is None, uses the path='.'.
set_blocking(fd, blocking, /)
Set the blocking mode of the specified file descriptor.
Set the O_NONBLOCK flag if blocking is False,
clear the O_NONBLOCK flag otherwise.
set_handle_inheritable(handle, inheritable, /)
Set the inheritable flag of the specified handle.
set_inheritable(fd, inheritable, /)
Set the inheritable flag of the specified file descriptor.
spawnl(mode, file, *args)
spawnl(mode, file, *args) -> integer
Execute file with arguments from args in a subprocess.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it.
spawnle(mode, file, *args)
spawnle(mode, file, *args, env) -> integer
Execute file with arguments from args in a subprocess with the
supplied environment.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it.
spawnv(mode, path, argv, /)
Execute the program specified by path in a new process.
mode
Mode of process creation.
path
Path of executable file.
argv
Tuple or list of strings.
spawnve(mode, path, argv, env, /)
Execute the program specified by path in a new process.
mode
Mode of process creation.
path
Path of executable file.
argv
Tuple or list of strings.
env
Dictionary of strings mapping to strings.
startfile(...)
Start a file with its associated application.
When "operation" is not specified or "open", this acts like
double-clicking the file in Explorer, or giving the file name as an
argument to the DOS "start" command: the file is opened with whatever
application (if any) its extension is associated.
When another "operation" is given, it specifies what should be done with
the file. A typical operation is "print".
"arguments" is passed to the application, but should be omitted if the
file is a document.
"cwd" is the working directory for the operation. If "filepath" is
relative, it will be resolved against this directory. This argument
should usually be an absolute path.
"show_cmd" can be used to override the recommended visibility option.
See the Windows ShellExecute documentation for values.
startfile returns as soon as the associated application is launched.
There is no option to wait for the application to close, and no way
to retrieve the application's exit status.
The filepath is relative to the current directory. If you want to use
an absolute path, make sure the first character is not a slash ("/");
the underlying Win32 ShellExecute function doesn't work if it is.
stat(path, *, dir_fd=None, follow_symlinks=True)
Perform a stat system call on the given path.
path
Path to be examined; can be string, bytes, a path-like object or
open-file-descriptor int.
dir_fd
If not None, it should be a file descriptor open to a directory,
and path should be a relative string; path will then be relative to
that directory.
follow_symlinks
If False, and the last element of the path is a symbolic link,
stat will examine the symbolic link itself instead of the file
the link points to.
dir_fd and follow_symlinks may not be implemented
on your platform. If they are unavailable, using them will raise a
NotImplementedError.
It's an error to use dir_fd or follow_symlinks when specifying path as
an open file descriptor.
strerror(code, /)
Translate an error code to a message string.
symlink(src, dst, target_is_directory=False, *, dir_fd=None)
Create a symbolic link pointing to src named dst.
target_is_directory is required on Windows if the target is to be
interpreted as a directory. (On Windows, symlink requires
Windows 6.0 or greater, and raises a NotImplementedError otherwise.)
target_is_directory is ignored on non-Windows platforms.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError.
system(command)
Execute the command in a subshell.
times()
Return a collection containing process timing information.
The object returned behaves like a named tuple with these fields:
(utime, stime, cutime, cstime, elapsed_time)
All fields are floating-point numbers.
truncate(path, length)
Truncate a file, specified by path, to a specific length.
On some platforms, path may also be specified as an open file descriptor.
If this functionality is unavailable, using it raises an exception.
umask(mask, /)
Set the current numeric umask and return the previous umask.
unlink(path, *, dir_fd=None)
Remove a file (same as remove()).
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError.
unsetenv(name, /)
Delete an environment variable.
urandom(size, /)
Return a bytes object containing random bytes suitable for cryptographic use.
utime(...)
Set the access and modified time of path.
path may always be specified as a string.
On some platforms, path may also be specified as an open file descriptor.
If this functionality is unavailable, using it raises an exception.
If times is not None, it must be a tuple (atime, mtime);
atime and mtime should be expressed as float seconds since the epoch.
If ns is specified, it must be a tuple (atime_ns, mtime_ns);
atime_ns and mtime_ns should be expressed as integer nanoseconds
since the epoch.
If times is None and ns is unspecified, utime uses the current time.
Specifying tuples for both times and ns is an error.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
If follow_symlinks is False, and the last element of the path is a symbolic
link, utime will modify the symbolic link itself instead of the file the
link points to.
It is an error to use dir_fd or follow_symlinks when specifying path
as an open file descriptor.
dir_fd and follow_symlinks may not be available on your platform.
If they are unavailable, using them will raise a NotImplementedError.
waitpid(pid, options, /)
Wait for completion of a given process.
Returns a tuple of information regarding the process:
(pid, status << 8)
The options argument is ignored on Windows.
waitstatus_to_exitcode(status)
Convert a wait status to an exit code.
On Unix:
* If WIFEXITED(status) is true, return WEXITSTATUS(status).
* If WIFSIGNALED(status) is true, return -WTERMSIG(status).
* Otherwise, raise a ValueError.
On Windows, return status shifted right by 8 bits.
On Unix, if the process is being traced or if waitpid() was called with
WUNTRACED option, the caller must first check if WIFSTOPPED(status) is true.
This function must not be called if WIFSTOPPED(status) is true.
walk(top, topdown=True, onerror=None, followlinks=False)
Directory tree generator.
For each directory in the directory tree rooted at top (including top
itself, but excluding '.' and '..'), yields a 3-tuple
dirpath, dirnames, filenames
dirpath is a string, the path to the directory. dirnames is a list of
the names of the subdirectories in dirpath (including symlinks to directories,
and excluding '.' and '..').
filenames is a list of the names of the non-directory files in dirpath.
Note that the names in the lists are just names, with no path components.
To get a full path (which begins with top) to a file or directory in
dirpath, do os.path.join(dirpath, name).
If optional arg 'topdown' is true or not specified, the triple for a
directory is generated before the triples for any of its subdirectories
(directories are generated top down). If topdown is false, the triple
for a directory is generated after the triples for all of its
subdirectories (directories are generated bottom up).
When topdown is true, the caller can modify the dirnames list in-place
(e.g., via del or slice assignment), and walk will only recurse into the
subdirectories whose names remain in dirnames; this can be used to prune the
search, or to impose a specific order of visiting. Modifying dirnames when
topdown is false has no effect on the behavior of os.walk(), since the
directories in dirnames have already been generated by the time dirnames
itself is generated. No matter the value of topdown, the list of
subdirectories is retrieved before the tuples for the directory and its
subdirectories are generated.
By default errors from the os.scandir() call are ignored. If
optional arg 'onerror' is specified, it should be a function; it
will be called with one argument, an OSError instance. It can
report the error to continue with the walk, or raise the exception
to abort the walk. Note that the filename is available as the
filename attribute of the exception object.
By default, os.walk does not follow symbolic links to subdirectories on
systems that support them. In order to get this functionality, set the
optional argument 'followlinks' to true.
Caution: if you pass a relative pathname for top, don't change the
current working directory between resumptions of walk. walk never
changes the current directory, and assumes that the client doesn't
either.
Example:
import os
from os.path import join, getsize
for root, dirs, files in os.walk('python/Lib/email'):
print(root, "consumes ")
print(sum(getsize(join(root, name)) for name in files), end=" ")
print("bytes in", len(files), "non-directory files")
if 'CVS' in dirs:
dirs.remove('CVS') # don't visit CVS directories
write(fd, data, /)
Write a bytes object to a file descriptor.
DATA
EX_OK = 0
F_OK = 0
O_APPEND = 8
O_BINARY = 32768
O_CREAT = 256
O_EXCL = 1024
O_NOINHERIT = 128
O_RANDOM = 16
O_RDONLY = 0
O_RDWR = 2
O_SEQUENTIAL = 32
O_SHORT_LIVED = 4096
O_TEMPORARY = 64
O_TEXT = 16384
O_TRUNC = 512
O_WRONLY = 1
P_DETACH = 4
P_NOWAIT = 1
P_NOWAITO = 3
P_OVERLAY = 2
P_WAIT = 0
R_OK = 4
SEEK_CUR = 1
SEEK_END = 2
SEEK_SET = 0
TMP_MAX = 2147483647
W_OK = 2
X_OK = 1
__all__ = ['altsep', 'curdir', 'pardir', 'sep', 'pathsep', 'linesep', ...
altsep = '/'
curdir = '.'
defpath = r'.;C:\bin'
devnull = 'nul'
environ = environ({'ALLUSERSPROFILE': 'C:\\ProgramData', '...undled\\l...
extsep = '.'
linesep = '\r\n'
name = 'nt'
pardir = '..'
pathsep = ';'
sep = r'\'
supports_bytes_environ = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\os.py
pyvista.parametric_keywords
Python Library Documentation: function parametric_keywords in module pyvista.core.utilities.parametric_objects
parametric_keywords(parametric_function: '_vtk.vtkParametricFunction', min_u: 'float' = 0.0, max_u: 'float' = 6.283185307179586, min_v: 'float' = 0.0, max_v: 'float' = 6.283185307179586, join_u: 'bool' = False, join_v: 'bool' = False, twist_u: 'bool' = False, twist_v: 'bool' = False, clockwise: 'bool' = True) -> 'None'
Apply keyword arguments to a parametric function.
Parameters
----------
parametric_function : :vtk:`vtkParametricFunction`
Parametric function to generate mesh from.
min_u : float, optional
The minimum u-value.
max_u : float, optional
The maximum u-value.
min_v : float, optional
The minimum v-value.
max_v : float, optional
The maximum v-value.
join_u : bool, optional
Joins the first triangle strip to the last one with a twist in
the u direction.
join_v : bool, optional
Joins the first triangle strip to the last one with a twist in
the v direction.
twist_u : bool, optional
Joins the first triangle strip to the last one with a twist in
the u direction.
twist_v : bool, optional
Joins the first triangle strip to the last one with a twist in
the v direction.
clockwise : bool, optional
Determines the ordering of the vertices forming the triangle
strips.
pyvista.parametric_objects
Python Library Documentation: module pyvista.core.utilities.parametric_objects in pyvista.core.utilities
NAME
pyvista.core.utilities.parametric_objects - Module managing parametric objects.
FUNCTIONS
KochanekSpline(points: 'VectorLike[float] | MatrixLike[float]', tension: 'VectorLike[float] | None' = None, bias: 'VectorLike[float] | None' = None, continuity: 'VectorLike[float] | None' = None, n_points: 'int | None' = None) -> 'PolyData'
Create a Kochanek spline from points.
Parameters
----------
points : array_like[float]
Array of points to build a Kochanek spline out of. Array must
be 3D and directionally ordered.
tension : sequence[float], default: [0.0, 0.0, 0.0]
Changes the length of the tangent vector.
bias : sequence[float], default: [0.0, 0.0, 0.0]
Primarily changes the direction of the tangent vector.
continuity : sequence[float], default: [0.0, 0.0, 0.0]
Changes the sharpness in change between tangents.
n_points : int, optional
Number of points on the spline. Defaults to ``points.shape[0]``.
Returns
-------
pyvista.PolyData
Kochanek spline.
Examples
--------
Construct a Kochanek spline.
>>> import numpy as np
>>> import pyvista as pv
>>> theta = np.linspace(-4 * np.pi, 4 * np.pi, 100)
>>> z = np.linspace(-2, 2, 100)
>>> r = z**2 + 1
>>> x = r * np.sin(theta)
>>> y = r * np.cos(theta)
>>> points = np.column_stack((x, y, z))
>>> kochanek_spline = pv.KochanekSpline(points, n_points=6)
>>> kochanek_spline.plot(line_width=4, color='k')
See :ref:`create_kochanek_spline_example` for an additional example.
ParametricBohemianDome(a: 'float | None' = None, b: 'float | None' = None, c: 'float | None' = None, **kwargs) -> 'PolyData'
Generate a Bohemian dome surface.
Parameters
----------
a : float, default: 0.5
Bohemian dome surface parameter a.
b : float, default: 1.5
Bohemian dome surface parameter b.
c : float, default: 1.0
Bohemian dome surface parameter c.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricBohemianDome surface.
Examples
--------
Create a ParametricBohemianDome mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricBohemianDome()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricBour(**kwargs) -> 'PolyData'
Generate Bour's minimal surface.
Parameters
----------
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricBour surface.
Examples
--------
Create a ParametricBour mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricBour()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricBoy(zscale: 'float | None' = None, **kwargs) -> 'PolyData'
Generate Boy's surface.
This is a model of the projective plane without singularities. It
was found by Werner Boy on assignment from David Hilbert.
For further information about this surface, please consult the
technical description "Parametric surfaces" in the
"VTK Technical Documents" section in the VTK.org web pages.
Parameters
----------
zscale : float, optional
The scale factor for the z-coordinate.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricBoy surface.
Examples
--------
Create a ParametricBoy mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricBoy()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricCatalanMinimal(**kwargs) -> 'PolyData'
Generate Catalan's minimal surface.
ParametricCatalanMinimal generates Catalan's minimal surface
parametrically. This minimal surface contains the cycloid as a
geodesic.
Parameters
----------
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricCatalanMinimal surface.
Examples
--------
Create a ParametricCatalanMinimal mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricCatalanMinimal()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricConicSpiral(a: 'float | None' = None, b: 'float | None' = None, c: 'float | None' = None, n: 'float | None' = None, **kwargs) -> 'PolyData'
Generate conic spiral surfaces that resemble sea-shells.
ParametricConicSpiral generates conic spiral surfaces. These can
resemble sea shells, or may look like a torus "eating" its own
tail.
Parameters
----------
a : float, default: 0.2
The scale factor.
b : float, default: 1
The A function coefficient.
See the definition in Parametric surfaces referred to above.
c : float, default: 0.1
The B function coefficient.
See the definition in Parametric surfaces referred to above.
n : float, default: 2
The C function coefficient.
See the definition in Parametric surfaces referred to above.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricConicSpiral surface.
Examples
--------
Create a ParametricConicSpiral mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricConicSpiral()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricCrossCap(**kwargs) -> 'PolyData'
Generate a cross-cap.
ParametricCrossCap generates a cross-cap which is a non-orientable
self-intersecting single-sided surface. This is one possible
image of a projective plane in three-space.
Parameters
----------
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricCrossCap surface.
Examples
--------
Create a ParametricCrossCap mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricCrossCap()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricDini(a: 'float | None' = None, b: 'float | None' = None, **kwargs) -> 'PolyData'
Generate Dini's surface.
ParametricDini generates Dini's surface. Dini's surface is a
surface that possesses constant negative Gaussian curvature
Parameters
----------
a : float, default: 1.0
The scale factor. See the definition in Parametric surfaces
referred to above.
b : float, default: 0.2
The scale factor. See the definition in Parametric surfaces
referred to above.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricDini surface.
Examples
--------
Create a ParametricDini mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricDini()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricEllipsoid(xradius: 'float | None' = None, yradius: 'float | None' = None, zradius: 'float | None' = None, **kwargs) -> 'PolyData'
Generate an ellipsoid.
ParametricEllipsoid generates an ellipsoid. If all the radii are
the same, we have a sphere. An oblate spheroid occurs if RadiusX
= RadiusY > RadiusZ. Here the Z-axis forms the symmetry axis. To
a first approximation, this is the shape of the earth. A prolate
spheroid occurs if RadiusX = RadiusY < RadiusZ.
Parameters
----------
xradius : float, default: 1.0
The scaling factor for the x-axis.
yradius : float, default: 1.0
The scaling factor for the y-axis.
zradius : float, default: 1.0
The scaling factor for the z-axis.
**kwargs : dict, optional
See :func:`surface_from_para` and :func:`parametric_keywords`
for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricEllipsoid surface.
Examples
--------
Create a ParametricEllipsoid mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricEllipsoid()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricEnneper(**kwargs) -> 'PolyData'
Generate Enneper's surface.
ParametricEnneper generates Enneper's surface. Enneper's surface
is a self-intersecting minimal surface possessing constant
negative Gaussian curvature.
Parameters
----------
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricEnneper surface.
Examples
--------
Create a ParametricEnneper mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricEnneper()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricFigure8Klein(radius: 'float | None' = None, **kwargs) -> 'PolyData'
Generate a figure-8 Klein bottle.
ParametricFigure8Klein generates a figure-8 Klein bottle. A Klein
bottle is a closed surface with no interior and only one surface.
It is unrealisable in 3 dimensions without intersecting surfaces.
Parameters
----------
radius : float, default: 1.0
The radius of the bottle.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricFigure8Klein surface.
Examples
--------
Create a ParametricFigure8Klein mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricFigure8Klein()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricHenneberg(**kwargs) -> 'PolyData'
Generate Henneberg's minimal surface.
Parameters
----------
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricHenneberg surface.
Examples
--------
Create a ParametricHenneberg mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricHenneberg()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricKlein(**kwargs) -> 'PolyData'
Generate a "classical" representation of a Klein bottle.
ParametricKlein generates a "classical" representation of a Klein
bottle. A Klein bottle is a closed surface with no interior and only one
surface. It is unrealisable in 3 dimensions without intersecting
surfaces.
Parameters
----------
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricKlein surface.
Examples
--------
Create a ParametricKlein mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricKlein()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricKuen(deltav0: 'float | None' = None, **kwargs) -> 'PolyData'
Generate Kuens' surface.
ParametricKuen generates Kuens' surface. This surface has a constant
negative Gaussian curvature.
Parameters
----------
deltav0 : float, default: 0.05
The value to use when ``V == 0``.
This has the best appearance with the default settings.
Setting it to a value less than 0.05 extrapolates the surface
towards a pole in the -z direction.
Setting it to 0 retains the pole whose z-value is -inf.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricKuen surface.
Examples
--------
Create a ParametricKuen mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricKuen()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricMobius(radius: 'float | None' = None, **kwargs) -> 'PolyData'
Generate a Mobius strip.
Parameters
----------
radius : float, default: 1.0
The radius of the Mobius strip.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricMobius surface.
Examples
--------
Create a ParametricMobius mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricMobius()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricPluckerConoid(n: 'int | None' = None, **kwargs) -> 'PolyData'
Generate Plucker's conoid surface.
ParametricPluckerConoid generates Plucker's conoid surface
parametrically. Plucker's conoid is a ruled surface, named after
Julius Plucker. It is possible to set the number of folds in this
class via the parameter 'n'.
Parameters
----------
n : int, optional
This is the number of folds in the conoid.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricPluckerConoid surface.
Examples
--------
Create a ParametricPluckerConoid mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricPluckerConoid()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricPseudosphere(**kwargs) -> 'PolyData'
Generate a pseudosphere.
ParametricPseudosphere generates a parametric pseudosphere. The
pseudosphere is generated as a surface of revolution of the
tractrix about it's asymptote, and is a surface of constant
negative Gaussian curvature.
Parameters
----------
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricPseudosphere surface.
Examples
--------
Create a ParametricPseudosphere mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricPseudosphere()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricRandomHills(number_of_hills: 'int | None' = None, hill_x_variance: 'float | None' = None, hill_y_variance: 'float | None' = None, hill_amplitude: 'float | None' = None, random_seed: 'int | None' = None, x_variance_scale_factor: 'float | None' = None, y_variance_scale_factor: 'float | None' = None, amplitude_scale_factor: 'float | None' = None, **kwargs) -> 'PolyData'
Generate a surface covered with randomly placed hills.
ParametricRandomHills generates a surface covered with randomly
placed hills. Hills will vary in shape and height since the
presence of nearby hills will contribute to the shape and height
of a given hill. An option is provided for placing hills on a
regular grid on the surface. In this case the hills will all have
the same shape and height.
Parameters
----------
number_of_hills : int, default: 30
The number of hills.
hill_x_variance : float, default: 2.5
The hill variance in the x-direction.
hill_y_variance : float, default: 2.5
The hill variance in the y-direction.
hill_amplitude : float, default: 2
The hill amplitude (height).
random_seed : int, default: 1
The Seed for the random number generator,
a value of 1 will initialize the random number generator,
a negative value will initialize it with the system time.
x_variance_scale_factor : float, default: 13
The scaling factor for the variance in the x-direction.
y_variance_scale_factor : float, default: 13
The scaling factor for the variance in the y-direction.
amplitude_scale_factor : float, default: 13
The scaling factor for the amplitude.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricRandomHills surface.
Examples
--------
Create a ParametricRandomHills mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricRandomHills()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricRoman(radius: 'float | None' = None, **kwargs) -> 'PolyData'
Generate Steiner's Roman Surface.
Parameters
----------
radius : float, default: 1
The radius.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricRoman surface.
Examples
--------
Create a ParametricRoman mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricRoman()
>>> mesh.plot(color='w', smooth_shading=True)
ParametricSuperEllipsoid(xradius: 'float | None' = None, yradius: 'float | None' = None, zradius: 'float | None' = None, n1: 'float | None' = None, n2: 'float | None' = None, **kwargs) -> 'PolyData'
Generate a superellipsoid.
ParametricSuperEllipsoid generates a superellipsoid. A superellipsoid
is a versatile primitive that is controlled by two parameters n1 and
n2. As special cases it can represent a sphere, square box, and closed
cylindrical can.
Parameters
----------
xradius : float, default: 1
The scaling factor for the x-axis.
yradius : float, default: 1
The scaling factor for the y-axis.
zradius : float, default: 1
The scaling factor for the z-axis.
n1 : float, default: 1
The "squareness" parameter in the z-axis.
n2 : float, default: 1
The "squareness" parameter in the x-y plane.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricSuperEllipsoid surface.
See Also
--------
pyvista.ParametricSuperToroid :
Toroidal equivalent of ParametricSuperEllipsoid.
pyvista.Superquadric :
Geometric object with additional parameters.
Examples
--------
Create a ParametricSuperEllipsoid surface that looks like a box
with smooth edges.
>>> import pyvista as pv
>>> mesh = pv.ParametricSuperEllipsoid(n1=0.02, n2=0.02)
>>> mesh.plot(color='w', smooth_shading=True)
Create one that looks like a spinning top.
>>> mesh = pv.ParametricSuperEllipsoid(n1=4, n2=0.5)
>>> mesh.plot(color='w', smooth_shading=True, cpos='xz')
ParametricSuperToroid(ringradius: 'float | None' = None, crosssectionradius: 'float | None' = None, xradius: 'float | None' = None, yradius: 'float | None' = None, zradius: 'float | None' = None, n1: 'float | None' = None, n2: 'float | None' = None, **kwargs) -> 'PolyData'
Generate a supertoroid.
ParametricSuperToroid generates a supertoroid. Essentially a
supertoroid is a torus with the sine and cosine terms raised to a power.
A supertoroid is a versatile primitive that is controlled by four
parameters r0, r1, n1 and n2. r0, r1 determine the type of torus whilst
the value of n1 determines the shape of the torus ring and n2 determines
the shape of the cross section of the ring. It is the different values of
these powers which give rise to a family of 3D shapes that are all
basically toroidal in shape.
Parameters
----------
ringradius : float, default: 1
The radius from the center to the middle of the ring of the
supertoroid.
crosssectionradius : float, default: 0.5
The radius of the cross section of ring of the supertoroid.
xradius : float, default: 1
The scaling factor for the x-axis.
yradius : float, default: 1
The scaling factor for the y-axis.
zradius : float, default: 1
The scaling factor for the z-axis.
n1 : float, default: 1
The shape of the torus ring.
n2 : float, default: 1
The shape of the cross section of the ring.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricSuperToroid surface.
See Also
--------
pyvista.ParametricSuperEllipsoid :
Ellipsoidal equivalent of ParametricSuperToroid.
pyvista.Superquadric :
Geometric object with additional parameters.
Examples
--------
Create a ParametricSuperToroid mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricSuperToroid(n1=2, n2=0.3)
>>> mesh.plot(color='w', smooth_shading=True)
ParametricTorus(ringradius: 'float | None' = None, crosssectionradius: 'float | None' = None, **kwargs) -> 'PolyData'
Generate a torus.
Parameters
----------
ringradius : float, default: 1.0
The radius from the center to the middle of the ring of the
torus.
crosssectionradius : float, default: 0.5
The radius of the cross section of ring of the torus.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
ParametricTorus surface.
Examples
--------
Create a ParametricTorus mesh.
>>> import pyvista as pv
>>> mesh = pv.ParametricTorus()
>>> mesh.plot(color='w', smooth_shading=True)
Spline(points: 'VectorLike[float] | MatrixLike[float]', n_points: 'int | None' = None, *, closed: 'bool' = False, parametrize_by: '_ParametrizeByOptions' = 'length', boundary_constraints: '_BoundaryConstraintOptions | tuple[_BoundaryConstraintOptions, _BoundaryConstraintOptions]' = 'clamped', boundary_values: 'float | tuple[float | None, float | None] | None' = None, **kwargs) -> 'PolyData'
Create a spline from points.
Parameters
----------
points : numpy.ndarray
Array of points to build a spline out of. Array must be 3D and
directionally ordered.
n_points : int, optional
Number of points to interpolate along the points array. Defaults to
``points.shape[0]``.
closed : bool, default: False
Close the spline if ``True`` (both ends are joined). Not closed by default.
parametrize_by : str, default: 'length'
Parametrize spline by ``'length'`` or by point ``'index'``.
boundary_constraints : str | Sequence[str], optional, default: 'clamped'
Derivative constraint type at both boundaries of the spline.
Can be set by a single string or a sequence of length 2 (one for each left/right end).
Each value must be one of:
- ``'finite_difference'``: The first derivative at the left(right) most point is determined
from the line defined from the first(last) two points.
- ``'clamped'``: Default: the first derivative at the left(right) most point is set to
Left(Right) ``boundary_values``. (Default)
- ``'second'``: The second derivative at the left(right) most point is set to
Left(Right) ``boundary_values``.
- ``'scaled_second'``: The second derivative at left(right) most points is
Left(Right) ``boundary_values`` times second derivative at first interior point.
boundary_values : float | Sequence[float | None], optional
Values of derivative at both ends of the spline used by the ``boundary_constraints`` type.
Can be set a single float, or a sequence of floats or None (one value for each left/right
end). If a single value is provided, the same value is used for both ends.
Value must be None for each end with boundary constraint type ``'finite_difference'``.
**kwargs : dict, optional
See :func:`surface_from_para` for additional keyword arguments.
Returns
-------
pyvista.PolyData
Line mesh of spline.
See Also
--------
:ref:`create_spline_example`
:ref:`distance_along_spline_example`
Examples
--------
Construct a spline.
>>> import numpy as np
>>> import pyvista as pv
>>> theta = np.linspace(-4 * np.pi, 4 * np.pi, 100)
>>> z = np.linspace(-2, 2, 100)
>>> r = z**2 + 1
>>> x = r * np.sin(theta)
>>> y = r * np.cos(theta)
>>> points = np.column_stack((x, y, z))
>>> spline = pv.Spline(points, 1000)
>>> spline.plot(
... render_lines_as_tubes=True,
... line_width=10,
... show_scalar_bar=False,
... )
parametric_keywords(parametric_function: '_vtk.vtkParametricFunction', min_u: 'float' = 0.0, max_u: 'float' = 6.283185307179586, min_v: 'float' = 0.0, max_v: 'float' = 6.283185307179586, join_u: 'bool' = False, join_v: 'bool' = False, twist_u: 'bool' = False, twist_v: 'bool' = False, clockwise: 'bool' = True) -> 'None'
Apply keyword arguments to a parametric function.
Parameters
----------
parametric_function : :vtk:`vtkParametricFunction`
Parametric function to generate mesh from.
min_u : float, optional
The minimum u-value.
max_u : float, optional
The maximum u-value.
min_v : float, optional
The minimum v-value.
max_v : float, optional
The maximum v-value.
join_u : bool, optional
Joins the first triangle strip to the last one with a twist in
the u direction.
join_v : bool, optional
Joins the first triangle strip to the last one with a twist in
the v direction.
twist_u : bool, optional
Joins the first triangle strip to the last one with a twist in
the u direction.
twist_v : bool, optional
Joins the first triangle strip to the last one with a twist in
the v direction.
clockwise : bool, optional
Determines the ordering of the vertices forming the triangle
strips.
surface_from_para(parametric_function: '_vtk.vtkParametricFunction', u_res: 'int' = 100, v_res: 'int' = 100, w_res: 'int' = 100, clean: 'bool' = False, texture_coordinates: 'bool' = False) -> 'PolyData'
Construct a mesh from a parametric function.
Parameters
----------
parametric_function : :vtk:`vtkParametricFunction`
Parametric function to generate mesh from.
u_res : int, default: 100
Resolution in the u direction.
v_res : int, default: 100
Resolution in the v direction.
w_res : int, default: 100
Resolution in the w direction.
clean : bool, default: False
Clean and merge duplicate points to avoid "creases" when
plotting with smooth shading.
texture_coordinates : bool, default: False
The generation of texture coordinates.
This is off by default. Note that this is only applicable
to parametric surfaces whose parametric dimension is 2.
Note that texturing may fail in some cases.
Returns
-------
pyvista.PolyData
Surface from the parametric function.
DATA
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
TYPE_CHECKING = False
pi = 3.141592653589793
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\parametric_objects.py
pyvista.parse_field_choice
Python Library Documentation: function parse_field_choice in module pyvista.core.utilities.arrays
parse_field_choice(field: "FieldAssociation | PointLiteral | CellLiteral | FieldLiteral | RowLiteral | Literal['p', 'c', 'f', 'r', 'points', 'cells', 'fields']") -> 'FieldAssociation'
Return a field association object for a given field type string.
Parameters
----------
field : str, FieldAssociation
Name of the field (e.g, ``'cell'``, ``'field'``, ``'point'``,
``'row'``).
Returns
-------
pyvista.FieldAssociation
Field association.
pyvista.partitioned
Python Library Documentation: module pyvista.core.partitioned in pyvista.core
NAME
pyvista.core.partitioned - Contains the PartitionedDataSet class.
CLASSES
collections.abc.MutableSequence(collections.abc.Sequence)
PartitionedDataSet(pyvista.core.dataobject.DataObject, collections.abc.MutableSequence, vtkmodules.vtkCommonDataModel.vtkPartitionedDataSet)
pyvista.core.dataobject.DataObject(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride)
PartitionedDataSet(pyvista.core.dataobject.DataObject, collections.abc.MutableSequence, vtkmodules.vtkCommonDataModel.vtkPartitionedDataSet)
vtkmodules.vtkCommonDataModel.vtkPartitionedDataSet(vtkmodules.vtkCommonDataModel.vtkDataObjectTree)
PartitionedDataSet(pyvista.core.dataobject.DataObject, collections.abc.MutableSequence, vtkmodules.vtkCommonDataModel.vtkPartitionedDataSet)
class PartitionedDataSet(pyvista.core.dataobject.DataObject, collections.abc.MutableSequence, vtkmodules.vtkCommonDataModel.vtkPartitionedDataSet)
| PartitionedDataSet(*args, **kwargs) -> '_T'
|
| Wrapper for the :vtk:`vtkPartitionedDataSet` class.
|
| DataSet which composite dataset to encapsulates a dataset consisting of partitions.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> partitions = pv.PartitionedDataSet(data)
| >>> len(partitions)
| 3
|
| Method resolution order:
| PartitionedDataSet
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| collections.abc.MutableSequence
| collections.abc.Sequence
| collections.abc.Reversible
| collections.abc.Collection
| collections.abc.Sized
| collections.abc.Iterable
| collections.abc.Container
| vtkmodules.vtkCommonDataModel.vtkPartitionedDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObjectTree
| vtkmodules.vtkCommonDataModel.vtkCompositeDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __delitem__(self, index: 'int | slice') -> 'None'
| Remove a partition at the specified index are not supported.
|
| __getitem__(self, index)
| Get a partition by its index.
|
| __init__(self, *args, **kwargs)
| Initialize the PartitionedDataSet.
|
| __len__(self) -> 'int'
| Return the number of partitions.
|
| __repr__(self) -> 'str'
| Define an adequate representation.
|
| __setitem__(self, index: 'int | slice', data)
| Set a partition with a VTK data object.
|
| __str__(self) -> 'str'
| Return the str representation of the multi partition.
|
| append(self, dataset) -> 'None'
| Add a data set to the next partition index.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to append to this partitioned dataset.
|
| copy(self, deep: 'bool' = True)
| Return a copy of the PartitionedDataSet.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True``, make a full copy of the object.
|
| Returns
| -------
| pyvista.PartitionedDataSet
| Deep or shallow copy of the ``PartitionedDataSet``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> data = [
| ... pv.Sphere(center=(2, 0, 0)),
| ... pv.Cube(center=(0, 2, 0)),
| ... pv.Cone(),
| ... ]
| >>> partitions = pv.PartitionedDataSet(data)
| >>> new_partitions = partitions.copy()
| >>> len(new_partitions)
| 3
|
| copy_meta_from(self, ido, deep) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| get_data_range(self: 'Self', name: 'str | None', preference: 'FieldAssociation | str') -> 'tuple[float, float]'
| Get the non-NaN min and max of a named array.
|
| insert(self, index: 'int', dataset: 'DataSet') -> 'None'
| Insert data before index.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| pop(self, index: 'int' = -1) -> 'None'
| Pop off a partition at the specified index are not supported.
|
| wrap_nested(self) -> 'None'
| Ensure that all nested data structures are wrapped as PyVista datasets.
|
| This is performed in place.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| is_empty
| Return ``True`` if there are no partitions.
|
| .. versionadded:: 0.46
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PartitionedDataSet()
| >>> mesh.is_empty
| True
|
| >>> mesh.append(pv.Sphere())
| >>> mesh.is_empty
| False
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| n_partitions
| Return the number of partitions.
|
| Returns
| -------
| int
| The number of partitions.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| shallow_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Shallow copy the given mesh to this mesh.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a shallow copy from.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from collections.abc.MutableSequence:
|
| __iadd__(self, values)
|
| clear(self)
| S.clear() -> None -- remove all items from S
|
| extend(self, values)
| S.extend(iterable) -- extend sequence by appending elements from the iterable
|
| remove(self, value)
| S.remove(value) -- remove first occurrence of value.
| Raise ValueError if the value is not present.
|
| reverse(self)
| S.reverse() -- reverse *IN PLACE*
|
| ----------------------------------------------------------------------
| Methods inherited from collections.abc.Sequence:
|
| __contains__(self, value)
|
| __iter__(self)
|
| __reversed__(self)
|
| count(self, value)
| S.count(value) -> integer -- return number of occurrences of value
|
| index(self, value, start=0, stop=None)
| S.index(value, [start, [stop]]) -> integer -- return first index of value.
| Raises ValueError if the value is not present.
|
| Supporting start and stop arguments is optional, but
| recommended.
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.abc.Reversible:
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.abc.Iterable:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkPartitionedDataSet:
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkPartitionedDataSet
| C++: static vtkPartitionedDataSet *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkPartitionedDataSet
| C++: static vtkPartitionedDataSet *GetData(
| vtkInformationVector *v, int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return class name of data type (see vtkType.h for definitions).
|
| GetMetaData(...)
| GetMetaData(self, idx:int) -> vtkInformation
| C++: vtkInformation *GetMetaData(unsigned int idx)
| GetMetaData(self, iter:vtkCompositeDataIterator) -> vtkInformation
| C++: vtkInformation *GetMetaData(vtkCompositeDataIterator *iter)
| override;
|
| Returns the meta-data for the partition. If none is already
| present, a new vtkInformation object will be allocated. Use
| HasMetaData to avoid allocating vtkInformation objects.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfPartitions(...)
| GetNumberOfPartitions(self) -> int
| C++: unsigned int GetNumberOfPartitions()
|
| Returns the number of partitions.
|
| GetPartition(...)
| GetPartition(self, idx:int) -> vtkDataSet
| C++: vtkDataSet *GetPartition(unsigned int idx)
|
| Returns the partition at the given index.
|
| GetPartitionAsDataObject(...)
| GetPartitionAsDataObject(self, idx:int) -> vtkDataObject
| C++: vtkDataObject *GetPartitionAsDataObject(unsigned int idx)
|
| HasMetaData(...)
| HasMetaData(self, idx:int) -> int
| C++: vtkTypeBool HasMetaData(unsigned int idx)
| HasMetaData(self, iter:vtkCompositeDataIterator) -> int
| C++: vtkTypeBool HasMetaData(vtkCompositeDataIterator *iter)
| override;
|
| Returns true if meta-data is available for a given partition.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkPartitionedDataSet
| C++: vtkPartitionedDataSet *NewInstance()
|
| RemoveNullPartitions(...)
| RemoveNullPartitions(self) -> None
| C++: void RemoveNullPartitions()
|
| Removes all partitions that have null datasets and resizes the
| dataset. Note any meta data associated with the null datasets
| will get lost.
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkPartitionedDataSet
| C++: static vtkPartitionedDataSet *SafeDownCast(vtkObjectBase *o)
|
| SetNumberOfPartitions(...)
| SetNumberOfPartitions(self, numPartitions:int) -> None
| C++: void SetNumberOfPartitions(unsigned int numPartitions)
|
| Set the number of partitions. This will cause allocation if the
| new number of partitions is greater than the current size. All
| new partitions are initialized to null.
|
| SetPartition(...)
| SetPartition(self, idx:int, partition:vtkDataObject) -> None
| C++: void SetPartition(unsigned int idx, vtkDataObject *partition)
|
| Sets the data object as the given partition. The total number of
| partitions will be resized to fit the requested partition no.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkPartitionedDataSet:
|
| __this__
| Pointer to the C++ object.
|
| data_object_type
| read-only, calls GetDataObjectType
|
| number_of_partitions
| read-write, calls GetNumberOfPartitions/SetNumberOfPartitions
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkPartitionedDataSet:
|
| __vtkname__ = 'vtkPartitionedDataSet'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObjectTree:
|
| CompositeShallowCopy(...)
| CompositeShallowCopy(self, src:vtkCompositeDataSet) -> None
| C++: void CompositeShallowCopy(vtkCompositeDataSet *src) override;
|
| CompositeShallow, Shallow and Deep copy.
|
| CopyStructure(...)
| CopyStructure(self, input:vtkCompositeDataSet) -> None
| C++: void CopyStructure(vtkCompositeDataSet *input) override;
|
| Copies the tree structure from the input. All pointers to
| non-composite data objects are initialized to nullptr. This also
| shallow copies the meta data associated with all the nodes.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated.
|
| GetChild(...)
| GetChild(self, index:int) -> vtkDataObject
| C++: vtkDataObject *GetChild(unsigned int index)
|
| Returns a child dataset at a given index.
|
| GetChildMetaData(...)
| GetChildMetaData(self, index:int) -> vtkInformation
| C++: vtkInformation *GetChildMetaData(unsigned int index)
|
| Returns the meta-data at a given index. If the index is valid,
| however, no information object is set, then a new one will
| created and returned. To avoid unnecessary creation, use
| HasMetaData().
|
| GetDataSet(...)
| GetDataSet(self, iter:vtkCompositeDataIterator) -> vtkDataObject
| C++: vtkDataObject *GetDataSet(vtkCompositeDataIterator *iter)
| override;
| GetDataSet(self, flatIndex:int) -> vtkDataObject
| C++: virtual vtkDataObject *GetDataSet(unsigned int flatIndex)
|
| Returns the dataset located at the position pointed by the
| iterator. The iterator does not need to be iterating over this
| dataset itself. It can be an iterator for composite dataset with
| similar structure (achieved by using CopyStructure).
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| Returns the total number of cells of all blocks. This will
| iterate over all blocks and call GetNumberOfPoints() so it might
| be expensive.
|
| GetNumberOfChildren(...)
| GetNumberOfChildren(self) -> int
| C++: unsigned int GetNumberOfChildren()
|
| Get the number of children.
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| Returns the total number of points of all blocks. This will
| iterate over all blocks and call GetNumberOfPoints() so it might
| be expansive.
|
| HasChildMetaData(...)
| HasChildMetaData(self, index:int) -> int
| C++: vtkTypeBool HasChildMetaData(unsigned int index)
|
| Returns if meta-data information is available for the given child
| index. Returns 1 is present, 0 otherwise.
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Restore data object to initial state,
|
| NewIterator(...)
| NewIterator(self) -> vtkCompositeDataIterator
| C++: vtkCompositeDataIterator *NewIterator() override;
|
| Return a new iterator (the iterator has to be deleted by user).
|
| * Use NewTreeIterator when you have a pointer to a
| vtkDataObjectTree
| * and NewIterator when you have a pointer to a
| vtkCompositeDataSet;
| * NewIterator is inherited and calls NewTreeIterator internally.
|
| NewTreeIterator(...)
| NewTreeIterator(self) -> vtkDataObjectTreeIterator
| C++: virtual vtkDataObjectTreeIterator *NewTreeIterator()
|
| Return a new iterator (the iterator has to be deleted by user).
|
| SetDataSet(...)
| SetDataSet(self, iter:vtkCompositeDataIterator,
| dataObj:vtkDataObject) -> None
| C++: void SetDataSet(vtkCompositeDataIterator *iter,
| vtkDataObject *dataObj) override;
|
| Sets the data set at the location pointed by the iterator. The
| iterator does not need to be iterating over this dataset itself.
| It can be any composite datasite with similar structure (achieved
| by using CopyStructure).
|
| SetDataSetFrom(...)
| SetDataSetFrom(self, iter:vtkDataObjectTreeIterator,
| dataObj:vtkDataObject) -> None
| C++: void SetDataSetFrom(vtkDataObjectTreeIterator *iter,
| vtkDataObject *dataObj)
|
| Sets the data at the location provided by a
| vtkDataObjectTreeIterator
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the data up to the array
| pointers only. The implementation is delegated to the differenent
| subclasses. If you want to copy the actual data, @see DeepCopy.
|
| This method shallow copy the field data and copy the internal
| structure.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObjectTree:
|
| number_of_cells
| read-only, calls GetNumberOfCells
|
| number_of_children
| read-only, calls GetNumberOfChildren
|
| number_of_points
| read-only, calls GetNumberOfPoints
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkCompositeDataSet:
|
| CURRENT_PROCESS_CAN_LOAD_BLOCK(...)
| CURRENT_PROCESS_CAN_LOAD_BLOCK() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *CURRENT_PROCESS_CAN_LOAD_BLOCK(
| )
|
| Key used to indicate that the current process can load the data
| in the node. Used for parallel readers where the nodes are
| assigned to the processes by the reader to indicate further down
| the pipeline which nodes will be on which processes.
| ***THIS IS AN EXPERIMENTAL KEY SUBJECT TO CHANGE WITHOUT
| NOTICE***\ingroup InformationKeys
|
| GetBounds(...)
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return the geometric bounding box in the form (xmin,xmax,
| ymin,ymax, zmin,zmax). Note that if the composite dataset
| contains abstract types (i.e., non vtkDataSet types) such as
| tables these will be ignored by the method. In cases where no
| vtkDataSet is contained in the composite dataset then the
| returned bounds will be undefined. THIS METHOD IS THREAD SAFE IF
| FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT
| MODIFIED.
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| NAME(...)
| NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *NAME()
|
| Key used to put node name in the meta-data associated with a
| node.\ingroup InformationKeys
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: virtual void Crop(const int *updateExtent)
|
| This method crops the data object (if necessary) so that the
| extent matches the update extent.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: virtual vtkFieldData *GetAttributesAsFieldData(int type)
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: virtual int GetExtentType()
|
| The ExtentType will be left as VTK_PIECES_EXTENT for data objects
| such as vtkPolyData and vtkUnstructuredGrid. The ExtentType will
| be changed to VTK_3D_EXTENT for data objects with 3D structure
| such as vtkImageData (and its subclass vtkStructuredPoints),
| vtkRectilinearGrid, and vtkStructuredGrid. The default is the
| have an extent in pieces, with only one piece (no streaming
| possible).
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: virtual vtkUnsignedCharArray *GetGhostArray(int type)
|
| Returns the ghost arrays of the data object of the specified
| attribute type. The type may be: POINT - Defined in
| vtkDataSet subclasses CELL - Defined in vtkDataSet subclasses.
| The other attribute types, will return nullptr since ghosts
| arrays are not defined for now outside of point or cell.
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Data objects are composite objects and need to check each part
| for MTime. The information object also needs to be considered.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| extent_type
| read-only, calls GetExtentType
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| m_time
| read-only, calls GetMTime
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
DATA
TYPE_CHECKING = False
vtk_version_info = VTKVersionInfo(major=9, minor=6, micro=2)
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\partitioned.py
pyvista.perlin_noise
Python Library Documentation: function perlin_noise in module pyvista.core.utilities.features
perlin_noise(amplitude, freq: 'Sequence[float]', phase: 'Sequence[float]')
Return the implicit function that implements Perlin noise.
Uses :vtk:`vtkPerlinNoise` and computes a Perlin noise field as
an implicit function. :vtk:`vtkPerlinNoise` is a concrete
implementation of :vtk:`vtkImplicitFunction`. Perlin noise,
originally described by Ken Perlin, is a non-periodic and
continuous noise function useful for modeling real-world objects.
The amplitude and frequency of the noise pattern are
adjustable. This implementation of Perlin noise is derived closely
from Greg Ward's version in Graphics Gems II.
Parameters
----------
amplitude : float
Amplitude of the noise function.
``amplitude`` can be negative. The noise function varies
randomly between ``-|Amplitude|`` and
``|Amplitude|``. Therefore the range of values is
``2*|Amplitude|`` large. The initial amplitude is 1.
freq : sequence[float]
The frequency, or physical scale, of the noise function
(higher is finer scale).
The frequency can be adjusted per axis, or the same for all axes.
phase : sequence[float]
Set/get the phase of the noise function.
This parameter can be used to shift the noise function within
space (perhaps to avoid a beat with a noise pattern at another
scale). Phase tends to repeat about every unit, so a phase of
0.5 is a half-cycle shift.
Returns
-------
:vtk:`vtkPerlinNoise`
Instance of :vtk:`vtkPerlinNoise` to a Perlin noise field as an
implicit function. Use with :func:`~pyvista.sample_function`.
See Also
--------
:ref:`perlin_noise_2d_example`
:ref:`perlin_noise_3d_example`
Examples
--------
Create a Perlin noise function with an amplitude of 0.1, frequency
for all axes of 1, and a phase of 0 for all axes.
>>> import pyvista as pv
>>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
Sample Perlin noise over a structured grid and plot it.
>>> grid = pv.sample_function(noise, bounds=[0, 5, 0, 5, 0, 5])
>>> grid.plot()
pyvista.plot
Python Library Documentation: function plot in module pyvista._plot
plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs)
Plot a PyVista, numpy, or vtk object.
.. versionadded:: 0.47
``plot`` can be invoked with the shell command:
.. code-block:: shell
pyvista plot <files> --screenshot output.png --off-screen
Run ``pyvista plot --help`` for more details on available parameters.
.. note::
Providing multiple files renders them inside the same window.
Parameters
----------
var_item : pyvista.DataSet
See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
supported types.
off_screen : bool, optional
Plots off screen when ``True``. Helpful for saving
screenshots without a window popping up. Defaults to the
global setting ``pyvista.OFF_SCREEN``.
full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
Opens window in full screen. When enabled, ignores
``window_size``.
screenshot : str | bool, optional
Saves screenshot to file when enabled. See:
:func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
Default ``False``.
When ``True``, takes screenshot and returns ``numpy`` array of
image.
interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
Allows user to pan and move figure.
cpos : CameraPositionOptions, optional
List of camera position, focal point, and view up.
See the :attr:`pyvista.Plotter.camera_position` for concrete examples
on how to use this parameter and :ref:`cameras_api` for a detailed
documentation on :class:`pyvista.Camera`.
window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
Window size in pixels.
show_bounds : bool, default: False
Shows mesh bounds when ``True``.
show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
Shows a vtk axes widget.
notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
When ``True``, the resulting plot is placed inline a jupyter
notebook. Assumes a jupyter console is active.
background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
Color of the background.
text : str, optional
Adds text at the bottom of the plot.
return_img : bool, default: False
Returns numpy array of the last image rendered.
eye_dome_lighting : bool, optional
Enables eye dome lighting.
volume : bool, default: False
Use the :func:`Plotter.add_volume()
<pyvista.Plotter.add_volume>` method for volume rendering.
parallel_projection : bool, default: False
Enable parallel projection.
jupyter_backend : JupyterBackendOptions, optional
Jupyter notebook plotting backend to use.
See available documentation at :func:`pyvista.set_jupyter_backend`
to see all valid values for this parameter along with a detailed documentation.
Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
return_viewer : bool, default: False
Return the jupyterlab viewer, scene, or display object
when plotting with jupyter notebook.
return_cpos : bool, default: False
Return the last camera position from the render window
when enabled. Defaults to value in theme settings.
jupyter_kwargs : dict, optional
Keyword arguments for the Jupyter notebook plotting backend.
See :ref:`customize_trame_toolbar_example` for an example
using this keyword.
theme : pyvista.plotting.themes.Theme, optional
Plot-specific theme.
anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
disables anti_aliasing. If a string, should be one of the following:
* ``"ssaa"`` - Super-Sample Anti-Aliasing
* ``"msaa"`` - Multi-Sample Anti-Aliasing
* ``"fxaa"`` - Fast Approximate Anti-Aliasing
Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
zoom : float | str, optional
Camera zoom. Either ``'tight'`` or a float. A value greater than 1
is a zoom-in, a value less than 1 is a zoom-out. Must be greater
than 0.
border : bool, default: False
Draw a border around each render window.
border_color : ColorLike, default: "k"
Either a string, rgb list, or hex color string. For example:
* ``color='white'``
* ``color='w'``
* ``color=[1.0, 1.0, 1.0]``
* ``color='#FFFFFF'``
border_width : float, default: 2.0
Width of the border in pixels when enabled.
ssao : bool, optional
Enable surface space ambient occlusion (SSAO). See
:func:`Plotter.enable_ssao` for more details.
**kwargs : dict, optional
See :func:`pyvista.Plotter.add_mesh` for additional options.
Returns
-------
cpos : list
List of camera position, focal point, and view up.
Returned only when ``return_cpos=True`` or set in the
default global or plot theme. Not returned when in a
jupyter notebook and ``return_viewer=True``.
image : np.ndarray
Numpy array of the last image when either ``return_img=True``
or ``screenshot=True`` is set. Not returned when in a
jupyter notebook with ``return_viewer=True``. Optionally
contains alpha values. Sized:
* [Window height x Window width x 3] if the theme sets
``transparent_background=False``.
* [Window height x Window width x 4] if the theme sets
``transparent_background=True``.
widget : ipywidgets.Widget
IPython widget when ``return_viewer=True``.
Examples
--------
Plot a simple sphere while showing its edges.
>>> import pyvista as pv
>>> mesh = pv.Sphere()
>>> mesh.plot(show_edges=True)
Plot a volume mesh. Color by distance from the center of the
ImageData. Note ``volume=True`` is passed.
>>> import numpy as np
>>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
>>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
>>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
>>> grid.plot(volume=True)
pyvista.point_array
Python Library Documentation: function point_array in module pyvista.core.utilities.arrays
point_array(obj: 'DataSet | _vtk.vtkDataSet', name: 'str') -> 'pyvista_ndarray | None'
Return point array of a pyvista or vtk object.
Parameters
----------
obj : DataSet | :vtk:`vtkDataSet`
PyVista or VTK dataset.
name : str | int
Name or index of the array.
Returns
-------
output : pyvista.pyvista_ndarray | None
Wrapped array if the index or name is valid. Otherwise, ``None``.
pyvista.points
Python Library Documentation: module pyvista.core.utilities.points in pyvista.core.utilities
NAME
pyvista.core.utilities.points - Points related utilities.
FUNCTIONS
fit_line_to_points(points: 'MatrixLike[float]', *, resolution: 'int' = 1, init_direction: 'VectorLike[float] | None' = None, return_meta: 'bool' = False) -> 'PolyData | tuple[PolyData, float, NumpyArray[float]]'
Fit a line to points using its :func:`principal_axes`.
The line is automatically sized and oriented to fit the extents of
the points.
.. versionadded:: 0.45.0
Parameters
----------
points : MatrixLike[float]
Size ``[N x 3]`` array of points to fit a line through.
resolution : int, default: 1
Number of pieces to divide the line into.
init_direction : VectorLike[float], optional
Flip the direction of the line's points such that it best aligns with this
vector. Can be a vector or string specifying the axis by name (e.g. ``'x'``
or ``'-x'``, etc.).
return_meta : bool, default: False
If ``True``, also returns the length (magnitude) and direction of the line.
See Also
--------
fit_plane_to_points
Fit a plane using the first two principal axes of the points.
principal_axes
Compute axes vectors which best fit a set of points.
Returns
-------
pyvista.PolyData
Line mesh.
float
Line length if ``return_meta=True``.
numpy.ndarray
Line direction (unit vector) if ``return_meta=True``.
Examples
--------
Download a point cloud. The points trace a path along topographical surface.
>>> import pyvista as pv
>>> from pyvista import examples
>>> mesh = examples.download_gpr_path()
Fit a line to the points and plot the result. The line of best fit is colored red.
>>> line = pv.fit_line_to_points(mesh.points)
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(mesh, color='black', line_width=10)
>>> _ = pl.add_mesh(line, color='red', line_width=5)
>>> pl.show()
Fit a line to a mesh and return the metadata.
>>> mesh = examples.download_human()
>>> line, length, direction = pv.fit_line_to_points(
... mesh.points, return_meta=True
... )
Show the length of the line.
>>> length
167.6145
Plot the line as an arrow to show its direction.
>>> arrow = pv.Arrow(
... start=line.points[0],
... direction=direction,
... scale=length,
... tip_length=0.2,
... tip_radius=0.04,
... shaft_radius=0.01,
... )
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(mesh, opacity=0.5)
>>> _ = pl.add_mesh(arrow, color='red')
>>> pl.show()
Set ``init_direction`` to the positive z-axis to flip the line's direction.
>>> mesh = examples.download_human()
>>> line, length, direction = pv.fit_line_to_points(
... mesh.points, init_direction='z', return_meta=True
... )
Plot the results again with an arrow.
>>> arrow = pv.Arrow(
... start=line.points[0],
... direction=direction,
... scale=length,
... tip_length=0.2,
... tip_radius=0.04,
... shaft_radius=0.01,
... )
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(mesh, opacity=0.5)
>>> _ = pl.add_mesh(arrow, color='red')
>>> pl.show()
fit_plane_to_points(points: 'MatrixLike[float]', return_meta: 'bool' = False, resolution: 'int' = 10, init_normal: 'VectorLike[float] | None' = None) -> 'PolyData | tuple[PolyData, float, NumpyArray[float]]'
Fit a plane to points using its :func:`principal_axes`.
The plane is automatically sized and oriented to fit the extents of
the points.
.. versionchanged:: 0.42.0
The generated plane is now sized and oriented to match the points.
.. versionchanged:: 0.42.0
The center of the plane (returned if ``return_meta=True``) is now
computed as the center of the generated plane mesh. In previous
versions, the center of the input points was returned.
.. versionchanged:: 0.45.0
The internal method used for fitting the plane has changed. Previously, singular
value decomposition (SVD) was used, but eigenvectors are now used instead.
See warning below.
.. warning::
The sign of the plane's normal vector prior to version 0.45 may differ
from the latest version. This may impact methods which rely on the plane's
direction. Use ``init_normal`` to control the sign explicitly.
Parameters
----------
points : array_like[float]
Size ``[N x 3]`` sequence of points to fit a plane through.
return_meta : bool, default: False
If ``True``, also returns the center and normal of the
generated plane.
resolution : int, default: 10
Number of points on the plane mesh along its edges. Specify two numbers to
set the resolution along the plane's long and short edge (respectively) or
a single number to set both edges to have the same resolution.
.. versionadded:: 0.45.0
init_normal : VectorLike[float] | str, optional
Flip the normal of the plane such that it best aligns with this vector. Can be
a vector or string specifying the axis by name (e.g. ``'x'`` or ``'-x'``, etc.).
.. versionadded:: 0.45.0
Returns
-------
pyvista.PolyData
Plane mesh.
pyvista.pyvista_ndarray
Plane center if ``return_meta=True``.
pyvista.pyvista_ndarray
Plane normal if ``return_meta=True``.
See Also
--------
fit_line_to_points
Fit a line using the first principal axis of the points.
principal_axes
Compute axes vectors which best fit a set of points.
Examples
--------
Fit a plane to a random point cloud.
>>> import pyvista as pv
>>> import numpy as np
>>> from pyvista import examples
>>>
>>> rng = np.random.default_rng(seed=0)
>>> cloud = rng.random((10, 3))
>>> cloud[:, 2] *= 0.1
>>>
>>> plane = pv.fit_plane_to_points(cloud)
Plot the point cloud and fitted plane.
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(plane, style='wireframe', line_width=4)
>>> _ = pl.add_points(
... cloud,
... render_points_as_spheres=True,
... color='r',
... point_size=30,
... )
>>> pl.show()
Fit a plane to a mesh and return its metadata. Set the plane resolution to 1
so that the plane has no internal points or edges.
>>> mesh = examples.download_shark()
>>> plane, center, normal = pv.fit_plane_to_points(
... mesh.points, return_meta=True, resolution=1
... )
Plot the mesh and fitted plane.
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(plane, show_edges=True, opacity=0.25)
>>> _ = pl.add_mesh(mesh, color='gray')
>>> pl.camera_position = pv.CameraPosition(
... position=(-117, 76, 235),
... focal_point=(1.69, -1.38, 0),
... viewup=(0.189, 0.957, -0.22),
... )
>>> pl.show()
Use the metadata with :meth:`pyvista.DataObjectFilters.clip` to split the mesh into
two.
>>> first_half, second_half = mesh.clip(
... origin=center, normal=normal, return_clipped=True
... )
Plot the two halves of the clipped mesh.
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(first_half, color='red')
>>> _ = pl.add_mesh(second_half, color='blue')
>>> pl.camera_position = pv.CameraPosition(
... position=(-143, 43, 40),
... focal_point=(-8.7, -11, -14),
... viewup=(0.25, 0.92, -0.29),
... )
>>> pl.show()
Note that it is pointing in the positive z-direction.
>>> normal # doctest:+SKIP
pyvista_ndarray([0.0, 0.0, 1.0], dtype=float32)
Use ``init_normal`` to flip the sign and make it negative instead.
>>> _, _, normal = pv.fit_plane_to_points(
... mesh.points, return_meta=True, init_normal='-z'
... )
>>> normal # doctest:+SKIP
pyvista_ndarray([0.0, 0.0, -1.0], dtype=float32)
line_segments_from_points(points: 'VectorLike[float] | MatrixLike[float]') -> 'PolyData'
Generate non-connected line segments from points.
Assumes points are ordered as line segments and an even number of
points.
Parameters
----------
points : array_like[float]
Points representing line segments. An even number must be
given as every two vertices represent a single line
segment. For example, two line segments would be represented
as ``np.array([[0, 0, 0], [1, 0, 0], [1, 0, 0], [1, 1, 0]])``.
Returns
-------
pyvista.PolyData
PolyData with lines and cells.
Examples
--------
This example plots two line segments at right angles to each other.
>>> import pyvista as pv
>>> import numpy as np
>>> points = np.array([[0, 0, 0], [1, 0, 0], [1, 0, 0], [1, 1, 0]])
>>> lines = pv.line_segments_from_points(points)
>>> lines.plot()
See :ref:`graph_network_example` for more examples using this function.
lines_from_points(points: 'VectorLike[float] | MatrixLike[float]', close: 'bool' = False) -> 'PolyData'
Make a connected line set given an array of points.
Parameters
----------
points : array_like[float]
Points representing the vertices of the connected
segments. For example, two line segments would be represented
as ``np.array([[0, 0, 0], [1, 0, 0], [1, 1, 0]])``.
close : bool, default: False
If ``True``, close the line segments into a loop.
Returns
-------
pyvista.PolyData
PolyData with lines and cells.
Examples
--------
>>> import numpy as np
>>> import pyvista as pv
>>> points = np.array([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
>>> poly = pv.lines_from_points(points)
>>> poly.plot(line_width=5)
See :ref:`lorenz_attractor_example` for more examples using this function.
make_tri_mesh(points: 'NumpyArray[float]', faces: 'NumpyArray[int]') -> 'PolyData'
Construct a ``pyvista.PolyData`` mesh using points and faces arrays.
Construct a mesh from an Nx3 array of points and an Mx3 array of
triangle indices, resulting in a mesh with N vertices and M
triangles. This function does not require the standard VTK
"padding" column and simplifies mesh creation.
Parameters
----------
points : np.ndarray
Array of points with shape ``(N, 3)`` storing the vertices of the
triangle mesh.
faces : np.ndarray
Array of indices with shape ``(M, 3)`` containing the triangle
indices.
Returns
-------
pyvista.PolyData
PolyData instance containing the triangle mesh.
Examples
--------
This example discretizes the unit square into a triangle mesh with
nine vertices and eight faces.
>>> import numpy as np
>>> import pyvista as pv
>>> points = np.array(
... [
... [0, 0, 0],
... [0.5, 0, 0],
... [1, 0, 0],
... [0, 0.5, 0],
... [0.5, 0.5, 0],
... [1, 0.5, 0],
... [0, 1, 0],
... [0.5, 1, 0],
... [1, 1, 0],
... ]
... )
>>> faces = np.array(
... [
... [0, 1, 4],
... [4, 7, 6],
... [2, 5, 4],
... [4, 5, 8],
... [0, 4, 3],
... [3, 4, 6],
... [1, 2, 4],
... [4, 8, 7],
... ]
... )
>>> tri_mesh = pv.make_tri_mesh(points, faces)
>>> tri_mesh.plot(show_edges=True, line_width=5)
principal_axes(points: 'MatrixLike[float]', *, return_std: 'bool' = False) -> 'NumpyArray[float] | tuple[NumpyArray[float], NumpyArray[float]]'
Compute the principal axes of a set of points.
Principal axes are orthonormal vectors that best fit a set of points. The axes
are also known as the principal components in Principal Component Analysis (PCA),
or the right singular vectors from the Singular Value Decomposition (SVD).
The axes are computed as the eigenvectors of the covariance matrix from the
mean-centered points, and are processed to ensure that they form a right-handed
coordinate frame.
The axes explain the total variance of the points. The first axis explains the
largest percentage of variance, followed by the second axis, followed again by
the third axis which explains the smallest percentage of variance.
The axes may be used to build an oriented bounding box or to align the points to
another set of axes (e.g. the world XYZ axes).
.. note::
The computed axes are not unique, and the sign of each axis direction can be
arbitrarily changed.
.. note::
This implementation creates a temporary array of the same size as the input
array, and is therefore not optimal in terms of its memory requirements.
A more memory-efficient computation may be supported in a future release.
.. versionadded:: 0.45.0
See Also
--------
fit_plane_to_points
Fit a plane to points using the first two principal axes.
pyvista.DataSetFilters.align_xyz
Filter which aligns principal axes to the x-y-z axes.
:ref:`point_cloud_orientation_example`
Example using this function with point clouds.
Parameters
----------
points : MatrixLike[float]
Nx3 array of points.
return_std : bool, default: False
If ``True``, also returns the standard deviation of the points along each axis.
Standard deviation is computed as the square root of the eigenvalues of the
mean-centered covariance matrix.
Returns
-------
numpy.ndarray
3x3 orthonormal array with the principal axes as row vectors.
numpy.ndarray
Three-item array of the standard deviations along each axis.
Examples
--------
>>> import pyvista as pv
>>> import numpy as np
>>> rng = np.random.default_rng(seed=0) # only seeding for the example
Create a mesh with points that have the largest variation in ``X``,
followed by ``Y``, then ``Z``.
>>> radii = np.array((6, 3, 1)) # x-y-z radii
>>> mesh = pv.ParametricEllipsoid(
... xradius=radii[0], yradius=radii[1], zradius=radii[2]
... )
Plot the mesh and highlight its points in black.
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(mesh)
>>> _ = pl.add_points(mesh, color='black')
>>> _ = pl.show_grid()
>>> pl.show()
Compute its principal axes and return the standard deviations.
>>> axes, std = pv.principal_axes(mesh.points, return_std=True)
>>> axes # doctest:+SKIP
pyvista_ndarray([[-1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., -1.]], dtype=float32)
Note that the principal axes have ones along the diagonal and zeros
in the off-diagonal. This indicates that the first principal axis is
aligned with the x-axis, the second with the y-axis, and third with
the z-axis. This is expected, since the mesh is already axis-aligned.
However, since the signs of the principal axes are arbitrary, the
first and third axes in this case have a negative direction.
Show the standard deviation along each axis.
>>> std # doctest:+SKIP
array([3.0149 , 1.5074 , 0.7035], dtype=float32)
Compare this to using :meth:`numpy.std` for the computation.
>>> np.std(mesh.points, axis=0)
pyvista_ndarray([3.0149572, 1.5074761, 0.7035699], dtype=float32)
Since the points are axis-aligned, the two results agree in this case. In general,
however, these two methods differ in that :meth:`numpy.std` with `axis=0` computes
the standard deviation along the `x-y-z` axes, whereas the standard deviation
returned by :meth:`principal_axes` is computed along the principal axes.
Convert the values to proportions for analysis.
>>> std / sum(std) # doctest:+SKIP
array([0.5769149 , 0.28845742, 0.1346276 ], dtype=float32)
From this result, we can determine that the axes explain approximately
58%, 29%, and 13% of the total variance in the points, respectively.
Let's compare this to the proportions of the known radii of the ellipsoid.
>>> radii / sum(radii)
array([0.6, 0.3, 0.1])
Note how the two ratios are similar, but do not match exactly. This is
because the points of the ellipsoid are prolate and are denser near the
poles. If the points were normally distributed, however, the proportions
would match exactly.
Create an array of normally distributed points scaled along the x-y-z axes.
Use the same scaling as the radii of the ellipsoid from the previous example.
>>> normal_points = rng.normal(size=(1000, 3))
>>> scaled_points = normal_points * radii
>>> axes, std = pv.principal_axes(scaled_points, return_std=True)
>>> axes
array([[-0.99997578, 0.00682346, 0.00136972],
[ 0.00681368, 0.99995213, -0.00702282],
[-0.00141757, -0.00701331, -0.9999744 ]])
Once again, the axes have ones along the diagonal as expected since the
points are already axis-aligned. Now let's examine the standard deviation
and compare the relative proportions.
>>> std
array([5.94466738, 2.89590334, 1.02103169])
>>> std / sum(std)
array([0.60280948, 0.29365444, 0.10353608])
>>> radii / sum(radii)
array([0.6, 0.3, 0.1])
Since the points are normally distributed, the relative proportion of
the standard deviation matches the scaling of the axes almost perfectly.
vector_poly_data(orig: 'VectorLike[float] | MatrixLike[float]', vec: 'VectorLike[float] | MatrixLike[float]') -> 'PolyData'
Create a pyvista.PolyData object composed of vectors.
Parameters
----------
orig : array_like[float]
Array of vector origins.
vec : array_like[float]
Array of vectors.
Returns
-------
pyvista.PolyData
Mesh containing the ``orig`` points along with the
``'vectors'`` and ``'mag'`` point arrays representing the
vectors and magnitude of the vectors at each point.
Examples
--------
Create basic vector field. This is a point cloud where each point
has a vector and magnitude attached to it.
>>> import pyvista as pv
>>> import numpy as np
>>> x, y = np.meshgrid(np.linspace(-5, 5, 10), np.linspace(-5, 5, 10))
>>> points = np.vstack((x.ravel(), y.ravel(), np.zeros(x.size))).T
>>> u = x / np.sqrt(x**2 + y**2)
>>> v = y / np.sqrt(x**2 + y**2)
>>> vectors = np.vstack((u.ravel() ** 3, v.ravel() ** 3, np.zeros(u.size))).T
>>> pdata = pv.vector_poly_data(points, vectors)
>>> pdata.point_data.keys()
['vectors', 'mag']
Convert these to arrows and plot it.
>>> pdata.glyph(orient='vectors', scale='mag').plot()
vtk_points(points: 'VectorLike[float] | MatrixLike[float]', deep: 'bool' = True, force_float: 'bool' = False, allow_empty: 'bool' = True) -> '_vtk.vtkPoints'
Convert numpy array or array-like to a :vtk:`vtkPoints` object.
Parameters
----------
points : numpy.ndarray or sequence
Points to convert. Should be 1 or 2 dimensional. Accepts a
single point or several points.
deep : bool, default: True
Perform a deep copy of the array. Only applicable if
``points`` is a :class:`numpy.ndarray`.
force_float : bool, default: False
Casts the datatype to ``float32`` if points datatype is
non-float. Set this to ``False`` to allow non-float types,
though this may lead to truncation of intermediate floats
when transforming datasets.
allow_empty : bool, default: True
Allow ``points`` to be an empty array. If ``False``, points
must be strictly one- or two-dimensional.
.. versionadded:: 0.45
Returns
-------
:vtk:`vtkPoints`
The :vtk:`vtkPoints` object.
Examples
--------
>>> import pyvista as pv
>>> import numpy as np
>>> points = np.random.default_rng().random((10, 3))
>>> vpoints = pv.vtk_points(points)
>>> vpoints # doctest:+SKIP
(vtkmodules.vtkCommonCore.vtkPoints)0x7f0c2e26af40
DATA
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
TYPE_CHECKING = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\points.py
pyvista.pointset
Python Library Documentation: module pyvista.core.pointset in pyvista.core
NAME
pyvista.core.pointset - Sub-classes and wrappers for :vtk:`vtkPointSet`.
CLASSES
pyvista.core.filters.poly_data.PolyDataFilters(pyvista.core.filters.data_set.DataSetFilters)
PolyData(_PointSet, pyvista.core.filters.poly_data.PolyDataFilters, vtkmodules.vtkCommonDataModel.vtkPolyData)
_PointSet(pyvista.core.dataset.DataSet)
PointGrid
ExplicitStructuredGrid(PointGrid, vtkmodules.vtkCommonDataModel.vtkExplicitStructuredGrid)
StructuredGrid(PointGrid, pyvista.core.filters.structured_grid.StructuredGridFilters, vtkmodules.vtkCommonDataModel.vtkStructuredGrid)
UnstructuredGrid(PointGrid, pyvista.core.filters.unstructured_grid.UnstructuredGridFilters, vtkmodules.vtkCommonDataModel.vtkUnstructuredGrid)
PointSet(_PointSet, vtkmodules.vtkCommonDataModel.vtkPointSet)
PolyData(_PointSet, pyvista.core.filters.poly_data.PolyDataFilters, vtkmodules.vtkCommonDataModel.vtkPolyData)
vtkmodules.vtkCommonDataModel.vtkPointSet(vtkmodules.vtkCommonDataModel.vtkDataSet)
PointSet(_PointSet, vtkmodules.vtkCommonDataModel.vtkPointSet)
vtkmodules.vtkCommonDataModel.vtkPolyData(vtkmodules.vtkCommonDataModel.vtkPointSet)
PolyData(_PointSet, pyvista.core.filters.poly_data.PolyDataFilters, vtkmodules.vtkCommonDataModel.vtkPolyData)
class ExplicitStructuredGrid(PointGrid, vtkmodules.vtkCommonDataModel.vtkExplicitStructuredGrid)
| ExplicitStructuredGrid(*args, **kwargs) -> '_T'
|
| Extend the functionality of the :vtk:`vtkExplicitStructuredGrid` class.
|
| Can be initialized by the following:
|
| - Creating an empty grid
| - From a :vtk:`vtkStructuredGrid`, :vtk:`vtkExplicitStructuredGrid` or
| :vtk:`vtkUnstructuredGrid` object
| - From a VTU or VTK file
| - From ``dims`` and ``corners`` arrays
| - From ``dims``, ``cells`` and ``points`` arrays
|
| Parameters
| ----------
| args : :vtk:`vtkExplicitStructuredGrid`, :vtk:`vtkUnstructuredGrid`, str, Sequence
| See examples below.
|
| deep : bool, default: False
| Whether to deep copy a :vtk:`vtkUnstructuredGrid` object.
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| :ref:`create_explicit_structured_grid_example`
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>>
| >>> # grid size: ni*nj*nk cells; si, sj, sk steps
| >>> ni, nj, nk = 4, 5, 6
| >>> si, sj, sk = 20, 10, 1
| >>>
| >>> # create raw coordinate grid
| >>> grid_ijk = np.mgrid[
| ... : (ni + 1) * si : si,
| ... : (nj + 1) * sj : sj,
| ... : (nk + 1) * sk : sk,
| ... ]
| >>>
| >>> # repeat array along each Cartesian axis for connectivity
| >>> for axis in range(1, 4):
| ... grid_ijk = grid_ijk.repeat(2, axis=axis)
| >>>
| >>> # slice off unnecessarily doubled edge coordinates
| >>> grid_ijk = grid_ijk[:, 1:-1, 1:-1, 1:-1]
| >>>
| >>> # reorder and reshape to VTK order
| >>> corners = grid_ijk.transpose().reshape(-1, 3)
| >>>
| >>> dims = np.array([ni, nj, nk]) + 1
| >>> grid = pv.ExplicitStructuredGrid(dims, corners)
| >>> grid = grid.compute_connectivity()
| >>> grid.plot(show_edges=True)
|
| Method resolution order:
| ExplicitStructuredGrid
| PointGrid
| _PointSet
| pyvista.core.dataset.DataSet
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkExplicitStructuredGrid
| vtkmodules.vtkCommonDataModel.vtkPointSet
| vtkmodules.vtkCommonDataModel.vtkDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, *args, deep: 'bool' = False, validate: 'bool | _NestedMeshValidationFields' = False)
| Initialize the explicit structured grid.
|
| __repr__(self) -> 'str'
| Return the standard representation.
|
| __str__(self) -> 'str'
| Return the standard ``str`` representation.
|
| cast_to_unstructured_grid(self) -> 'UnstructuredGrid'
| Cast to an unstructured grid.
|
| Returns
| -------
| UnstructuredGrid
| An unstructured grid. VTK adds the ``'BLOCK_I'``,
| ``'BLOCK_J'`` and ``'BLOCK_K'`` cell arrays. These arrays
| are required to restore the explicit structured grid.
|
| See Also
| --------
| pyvista.DataSetFilters.extract_cells : Extract a subset of a dataset.
| pyvista.UnstructuredGrid.cast_to_explicit_structured_grid
| Cast an unstructured grid to an explicit structured grid.
|
| Notes
| -----
| The ghost cell array is disabled before casting the
| unstructured grid in order to allow the original structure
| and attributes data of the explicit structured grid to be
| restored. If you don't need to restore the explicit
| structured grid later or want to extract an unstructured
| grid from the visible subgrid, use the ``extract_cells``
| filter and the cell indices where the ghost cell array is
| ``0``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| >>> grid = grid.hide_cells(range(80, 120))
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| >>> grid = grid.cast_to_unstructured_grid()
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| >>> grid = grid.cast_to_explicit_structured_grid()
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| cell_coords(self, ind: 'int | VectorLike[int]') -> 'None | MatrixLike[int]'
| Return the cell structured coordinates.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell IDs.
|
| Returns
| -------
| output : numpy.ndarray | None
| Cell structured coordinates. ``None`` if ``ind`` is
| outside the grid extent.
|
| See Also
| --------
| pyvista.ExplicitStructuredGrid.cell_id : Return the cell ID.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid.cell_coords(19)
| array([3, 4, 0])
|
| >>> grid.cell_coords((19, 31, 41, 54))
| array([[3, 4, 0],
| [3, 2, 1],
| [1, 0, 2],
| [2, 3, 2]])
|
| cell_id(self, coords: 'ArrayLike[int]') -> 'int | NumpyArray[int] | None'
| Return the cell ID.
|
| Parameters
| ----------
| coords : ArrayLike[int]
| Cell structured coordinates.
|
| Returns
| -------
| output : int | numpy.ndarray | None
| Cell IDs. ``None`` if ``coords`` is outside the grid extent.
|
| See Also
| --------
| pyvista.ExplicitStructuredGrid.cell_coords : Return the cell structured coordinates.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid.cell_id((3, 4, 0))
| np.int64(19)
|
| >>> coords = [(3, 4, 0), (3, 2, 1), (1, 0, 2), (2, 3, 2)]
| >>> grid.cell_id(coords)
| array([19, 31, 41, 54])
|
| clean(self, tolerance=0, remove_unused_points: 'bool' = True, produce_merge_map: 'bool' = True, average_point_data: 'bool' = True, merging_array_name=None, progress_bar: 'bool' = False) -> 'ExplicitStructuredGrid'
| Merge duplicate points and remove unused points in an ExplicitStructuredGrid.
|
| This filter, merging coincident points as defined by a merging
| tolerance and optionally removes unused points. The filter does not
| modify the topology of the input dataset, nor change the types of
| cells. It may however, renumber the cell connectivity ids.
|
| This filter casts the grid to an UnstructuredGrid to clean it, then
| casts the cleaned unstructured grid to an explicit structured grid.
|
| Parameters
| ----------
| tolerance : float, default: 0.0
| The absolute point merging tolerance.
|
| remove_unused_points : bool, default: True
| Indicate whether points unused by any cell are removed from the
| output. Note that when this is off, the filter can successfully
| process datasets with no cells (and just points). If on in this
| case, and there are no cells, the output will be empty.
|
| produce_merge_map : bool, default: False
| Indicate whether a merge map should be produced on output.
| The merge map, if requested, maps each input point to its
| output point id, or provides a value of -1 if the input point
| is not used in the output. The merge map is associated with
| the filter's output field data and is named ``"PointMergeMap"``.
|
| average_point_data : bool, default: True
| Indicate whether point coordinates and point data of merged points
| are averaged. When ``True``, the data coordinates and attribute
| values of all merged points are averaged. When ``False``, the point
| coordinate and data of the single remaining merged point is
| retained.
|
| merging_array_name : str, optional
| If a ``merging_array_name`` is specified and exists in the
| ``point_data``, then point merging will switch into a mode where
| merged points must be both geometrically coincident and have
| matching point data. When set, ``tolerance`` has no effect.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ExplicitStructuredGrid
| Cleaned explicit structured grid.
|
| compute_connections(self, inplace: 'bool' = False) -> 'Self'
| Compute an array with the number of connected cell faces.
|
| This method calculates the number of topological cell
| neighbors connected by faces. The results are stored in the
| ``'number_of_connections'`` cell array.
|
| Parameters
| ----------
| inplace : bool, default: False
| This method is applied to this grid if ``True`` or to a copy
| otherwise.
|
| Returns
| -------
| ExplicitStructuredGrid
| A deep copy of this grid if ``inplace=False`` or this
| DataSet if otherwise.
|
| See Also
| --------
| ExplicitStructuredGrid.compute_connectivity : Compute the faces connectivity flags array.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid = grid.compute_connections()
| >>> grid.plot(show_edges=True)
|
| compute_connectivity(self, inplace: 'bool' = False) -> 'Self'
| Compute the faces connectivity flags array.
|
| This method checks the faces connectivity of the cells with
| their topological neighbors. The result is stored in the
| array of integers ``'ConnectivityFlags'``. Each value in this
| array must be interpreted as a binary number, where the digits
| shows the faces connectivity of a cell with its topological
| neighbors -Z, +Z, -Y, +Y, -X and +X respectively. For example,
| a cell with ``'ConnectivityFlags'`` equal to ``27``
| (``011011``) indicates that this cell is connected by faces
| with their neighbors ``(0, 0, 1)``, ``(0, -1, 0)``,
| ``(-1, 0, 0)`` and ``(1, 0, 0)``.
|
| Parameters
| ----------
| inplace : bool, default: False
| This method is applied to this grid if ``True``
| or to a copy otherwise.
|
| Returns
| -------
| ExplicitStructuredGrid
| A deep copy of this grid if ``inplace=False``, or this
| DataSet if otherwise.
|
| See Also
| --------
| ExplicitStructuredGrid.compute_connections
| Compute an array with the number of connected cell faces.
|
| Examples
| --------
| >>> from pyvista import examples
| >>>
| >>> grid = examples.load_explicit_structured()
| >>> grid = grid.compute_connectivity()
| >>> grid.plot(show_edges=True)
|
| hide_cells(self, ind: 'VectorLike[int]', inplace: 'bool' = False) -> 'Self'
| Hide specific cells.
|
| Hides cells by setting the ghost cell array to ``HIDDENCELL``.
|
| Parameters
| ----------
| ind : sequence[int]
| Cell indices to be hidden. A boolean array of the same
| size as the number of cells also is acceptable.
|
| inplace : bool, default: False
| This method is applied to this grid if ``True``
| or to a copy otherwise.
|
| Returns
| -------
| output : ExplicitStructuredGrid | None
| A deep copy of this grid if ``inplace=False`` with the
| hidden cells, or this grid with the hidden cells if
| otherwise.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid = grid.hide_cells(range(80, 120))
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| neighbors(self, ind: 'int | VectorLike[int]', rel: 'str' = 'connectivity') -> 'list[int]'
| Return the indices of neighboring cells.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell IDs.
|
| rel : str, default: "connectivity"
| Defines the neighborhood relationship. If
| ``'topological'``, returns the ``(i-1, j, k)``, ``(i+1, j,
| k)``, ``(i, j-1, k)``, ``(i, j+1, k)``, ``(i, j, k-1)``
| and ``(i, j, k+1)`` cells. If ``'connectivity'``
| (default), returns only the topological neighbors
| considering faces connectivity. If ``'geometric'``,
| returns the cells in the ``(i-1, j)``, ``(i+1, j)``,
| ``(i,j-1)`` and ``(i, j+1)`` vertical cell groups whose
| faces intersect.
|
| Returns
| -------
| list[int]
| Indices of neighboring cells.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> cell = grid.extract_cells(31)
| >>> ind = grid.neighbors(31)
| >>> neighbors = grid.extract_cells(ind)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_axes()
| >>> _ = pl.add_mesh(cell, color='r', show_edges=True)
| >>> _ = pl.add_mesh(neighbors, color='w', show_edges=True)
| >>> pl.show()
|
| save(self, filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this VTK object to file.
|
| Parameters
| ----------
| filename : Path, str
| Output file name. VTU and VTK extensions are supported.
|
| binary : bool, default: True
| If ``True``, write as binary, else ASCII.
|
| texture : np.ndarray, str, None
| Ignored argument. Kept to maintain compatibility with supertype.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. When
| the target extension dispatches to a built-in VTK writer or
| to the pickle path, passing any extra keyword arguments
| raises :class:`TypeError`.
|
| .. versionadded:: 0.48
|
| Notes
| -----
| VTK adds the ``'BLOCK_I'``, ``'BLOCK_J'`` and ``'BLOCK_K'``
| cell arrays. These arrays are required to restore the explicit
| structured grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured() # doctest:+SKIP
| >>> grid = grid.hide_cells(range(80, 120)) # doctest:+SKIP
| >>> grid.save('grid.vtu') # doctest:+SKIP
|
| >>> grid = pv.ExplicitStructuredGrid('grid.vtu') # doctest:+SKIP
| >>> grid.plot(color='w', show_edges=True, show_bounds=True) # doctest:+SKIP
|
| >>> grid.show_cells() # doctest:+SKIP
| >>> grid.plot(color='w', show_edges=True, show_bounds=True) # doctest:+SKIP
|
| show_cells(self, inplace: 'bool' = False) -> 'Self'
| Show hidden cells.
|
| Shows hidden cells by setting the ghost cell array to ``0``
| where ``HIDDENCELL``.
|
| Parameters
| ----------
| inplace : bool, default: False
| This method is applied to this grid if ``True``
| or to a copy otherwise.
|
| Returns
| -------
| ExplicitStructuredGrid
| A deep copy of this grid if ``inplace=False`` with the
| hidden cells shown. Otherwise, this dataset with the
| shown cells.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid = grid.hide_cells(range(80, 120))
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| >>> grid = grid.show_cells()
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| dimensions
| Return the topological dimensions of the grid.
|
| Returns
| -------
| tuple[int, int, int]
| Number of sampling points in the I, J and Z directions respectively.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid.dimensions
| (5, 6, 7)
|
| visible_bounds
| Return the bounding box of the visible cells.
|
| Different from `bounds`, which returns the bounding box of the
| complete grid, this method returns the bounding box of the
| visible cells, where the ghost cell array is not
| ``HIDDENCELL``.
|
| Returns
| -------
| tuple[float, float, float]
| The limits of the visible grid in the X, Y and Z
| directions respectively.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid = grid.hide_cells(range(80, 120))
| >>> grid.bounds
| BoundsTuple(x_min = 0.0,
| x_max = 80.0,
| y_min = 0.0,
| y_max = 50.0,
| z_min = 0.0,
| z_max = 6.0)
|
| >>> grid.visible_bounds
| BoundsTuple(x_min = 0.0,
| x_max = 80.0,
| y_min = 0.0,
| y_max = 50.0,
| z_min = 0.0,
| z_max = 4.0)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| ----------------------------------------------------------------------
| Methods inherited from PointGrid:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| plot_curvature(self: 'Self', curv_type='mean', **kwargs)
| Plot the curvature of the external surface of the grid.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| One of the following strings indicating curvature types.
| - ``'mean'``
| - ``'gaussian'``
| - ``'maximum'``
| - ``'minimum'``
|
| **kwargs : dict, optional
| Optional keyword arguments. See :func:`pyvista.plot`.
|
| Returns
| -------
| list
| Camera position, focal point, and view up. Returned when
| ``return_cpos`` is ``True``.
|
| ----------------------------------------------------------------------
| Methods inherited from _PointSet:
|
| center_of_mass(self, scalars_weight: 'bool' = False) -> 'NumpyArray[float]'
| Return the coordinates for the center of mass of the mesh.
|
| Parameters
| ----------
| scalars_weight : bool, default: False
| Flag for using the mesh scalars as weights.
|
| Returns
| -------
| numpy.ndarray
| Coordinates for the center of mass.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 1, 1))
| >>> mesh.center_of_mass()
| array([1., 1., 1.])
|
| points_to_double(self) -> 'Self'
| Convert the points datatype to double precision.
|
| Returns
| -------
| pyvista.PointSet
| Pointset with points in double precision.
|
| Notes
| -----
| This operates in place.
|
| Examples
| --------
| Create a mesh that has points of the type ``float32`` and
| convert the points to ``float64``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.points.dtype
| dtype('float32')
| >>> _ = mesh.points_to_double()
| >>> mesh.points.dtype
| dtype('float64')
|
| remove_cells(self, ind: 'VectorLike[bool] | VectorLike[int]', inplace: 'bool' = False) -> '_PointSet'
| Remove cells.
|
| Parameters
| ----------
| ind : VectorLike[int] | VectorLike[bool]
| Cell indices to be removed. The array can also be a
| boolean array of the same size as the number of cells.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| Returns
| -------
| pyvista.DataSet
| Same type as the input, but with the specified cells
| removed.
|
| See Also
| --------
| :ref:`ghost_cells_example`
|
| Examples
| --------
| Remove 20 cells from an unstructured grid.
|
| >>> from pyvista import examples
| >>> import pyvista as pv
| >>> hex_mesh = pv.read(examples.hexbeamfile)
| >>> removed = hex_mesh.remove_cells(range(10, 20))
| >>> removed.plot(color='lightblue', show_edges=True, line_width=3)
|
| shallow_copy(self, to_copy: 'DataSet') -> 'None'
| Create a shallow copy from a different dataset into this one.
|
| This method mutates this dataset and returns ``None``.
|
| Parameters
| ----------
| to_copy : pyvista.DataSet
| Data object to perform the shallow copy from.
|
| translate(self: 'Self', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False)
| Translate the mesh.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats of cartesian values to translate the mesh with.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed. This is
| only valid when not updating in place.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PointSet
| Translated pointset.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=True)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkExplicitStructuredGrid:
|
| BlankCell(...)
| BlankCell(self, cellId:int) -> None
| C++: void BlankCell(vtkIdType cellId)
|
| Methods for supporting blanking of cells. Blanking turns on or
| off cells in the structured grid. These methods should be called
| only after the dimensions of the grid are set.
|
| BuildLinks(...)
| BuildLinks(self) -> None
| C++: void BuildLinks()
|
| Build topological links from points to lists of cells that use
| each point. See vtkAbstractCellLinks for more information.
|
| CheckAndReorderFaces(...)
| CheckAndReorderFaces(self) -> None
| C++: void CheckAndReorderFaces()
|
| Check faces are numbered correctly regarding ijk numbering If not
| this will reorganize cell points order so face order is valid.
| This is made in two pass, first it check that faces are on the
| correct axis and corrects it Then it check if faces are mirrored
| and corrects it. Make sure cells and extent have been set before
| calling this method and recompute face connectivity afterwards.
|
| ComputeCellId(...)
| ComputeCellId(self, i:int, j:int, k:int,
| adjustForExtent:bool=True) -> int
| C++: vtkIdType ComputeCellId(int i, int j, int k,
| bool adjustForExtent=true)
|
| Given a location in structured coordinates (i-j-k), return the
| cell id. If adjustForExtent is true, (i,j,k) is interpreted as a
| position relative to the beginning of the extent. If
| adjustForExtent is false, (i,j,k) is interpreted literally and
| the cell id is returned regardless of the extent beginning. The
| default adjustForExtent is true.
|
| ComputeCellStructuredCoords(...)
| ComputeCellStructuredCoords(self, cellId:int, i:int, j:int, k:int,
| adjustForExtent:bool=True) -> None
| C++: void ComputeCellStructuredCoords(vtkIdType cellId, int &i,
| int &j, int &k, bool adjustForExtent=true)
|
| Given a cellId, get the structured coordinates (i-j-k). If
| adjustForExtent is true, (i,j,k) is computed as a position
| relative to the beginning of the extent. If adjustForExtent is
| false, (i,j,k) is computed regardless of the extent beginning.
| The default adjustForExtent is true.
|
| ComputeFacesConnectivityFlagsArray(...)
| ComputeFacesConnectivityFlagsArray(self) -> None
| C++: void ComputeFacesConnectivityFlagsArray()
|
| Compute the faces connectivity flags array. This method should be
| called after the construction if the ESG is to be used by other
| filters.
|
| CopyStructure(...)
| CopyStructure(self, ds:vtkDataSet) -> None
| C++: void CopyStructure(vtkDataSet *ds) override;
|
| Copy the geometric and topological structure of an input poly
| data object.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: void Crop(const int *updateExtent) override;
| Crop(self, input:vtkExplicitStructuredGrid, updateExtent:(int,
| ...), generateOriginalCellIds:bool) -> None
| C++: virtual void Crop(vtkExplicitStructuredGrid *input,
| const int *updateExtent, bool generateOriginalCellIds)
|
| Reallocates and copies to set the Extent to the UpdateExtent.
| This is used internally when the exact extent is requested, and
| the source generated more than the update extent.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| GenerateGhostArray(...)
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int],
| cellOnly:bool) -> None
| C++: void GenerateGhostArray(int zeroExt[6], bool cellOnly)
| override;
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int])
| -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6])
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kilobytes. This number is
| valid only after the pipeline has updated. The memory size
| returned is guaranteed to be greater than or equal to the memory
| required to represent the data (e.g., extra space in arrays, etc.
| are not included in the return value). THIS METHOD IS THREAD
| SAFE.
|
| GetCell(...)
| GetCell(self, cellId:int) -> vtkCell
| C++: vtkCell *GetCell(vtkIdType cellId) override;
| GetCell(self, cellId:int, cell:vtkGenericCell) -> None
| C++: void GetCell(vtkIdType cellId, vtkGenericCell *cell)
| override;
| GetCell(self, i:int, j:int, k:int) -> vtkCell
| C++: virtual vtkCell *GetCell(int i, int j, int k)
|
| This method always return a `vtkEmptyCell`, as there is no cell
| in a `vtkPointSet`.
|
| GetCellBounds(...)
| GetCellBounds(self, cellId:int, bounds:[float, float, float,
| float, float, float]) -> None
| C++: void GetCellBounds(vtkIdType cellId, double bounds[6])
| override;
|
| Get the bounds of the cell with cellId such that: 0 <= cellId <
| NumberOfCells. A subclass may be able to determine the bounds of
| cell without using an expensive GetCell() method. A default
| implementation is provided that actually uses a GetCell() call.
| This is to ensure the method is available to all datasets.
| Subclasses should override this method to provide an efficient
| implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetCellDims(...)
| GetCellDims(self, cellDims:[int, int, int]) -> None
| C++: void GetCellDims(int cellDims[3])
|
| Computes the cell dimensions according to internal point
| dimensions. The total number of cells can be achieved simply by
| cellDims[0] * cellDims[1] * cellDims[2].
|
| GetCellNeighbors(...)
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds) override;
| GetCellNeighbors(self, cellId:int, neighbors:[int, int, int, int,
| int, int], wholeExtent:[int, ...]=...) -> None
| C++: void GetCellNeighbors(vtkIdType cellId,
| vtkIdType neighbors[6], int *wholeExtent=nullptr)
|
| Topological inquiry to get all cells using list of points
| exclusive of cell specified (e.g., cellId). Note that the list
| consists of only cells that use ALL the points provided. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetCellPoints(...)
| GetCellPoints(self, cellId:int, ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
| override;
| GetCellPoints(self, cellId:int) -> Pointer
| C++: vtkIdType *GetCellPoints(vtkIdType cellId)
| GetCellPoints(self, cellId:int, npts:int, pts:[int, ...]) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType *&pts)
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...),
| ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts, vtkIdList *ptIds) override;
|
| Topological inquiry to get points defining cell. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| GetCellSize(...)
| GetCellSize(self, cellId:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType cellId) override;
|
| This method always returns 1, as all cells are point in a pure
| `vtkPointSet`.
|
| GetCellType(...)
| GetCellType(self, cellId:int) -> int
| C++: int GetCellType(vtkIdType cellId) override;
|
| This method always returns `VTK_EMPTY_CELL`, as there is no cell
| in a `vtkPointSet`.
|
| GetCells(...)
| GetCells(self) -> vtkCellArray
| C++: virtual vtkCellArray *GetCells()
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkExplicitStructuredGrid
| C++: static vtkExplicitStructuredGrid *GetData(
| vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0)
| -> vtkExplicitStructuredGrid
| C++: static vtkExplicitStructuredGrid *GetData(
| vtkInformationVector *v, int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataDimension(...)
| GetDataDimension(self) -> int
| C++: int GetDataDimension()
|
| Return the dimensionality of the data.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return what type of dataset this is.
|
| GetDimensions(...)
| GetDimensions(self, dim:[int, int, int]) -> None
| C++: void GetDimensions(int dim[3])
|
| GetExtent(...)
| GetExtent(self) -> (int, int, int, int, int, int)
| C++: virtual int *GetExtent()
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: int GetExtentType() override;
|
| The extent type is a 3D extent
|
| GetFacesConnectivityFlagsArrayName(...)
| GetFacesConnectivityFlagsArrayName(self) -> str
| C++: virtual char *GetFacesConnectivityFlagsArrayName()
|
| GetLinks(...)
| GetLinks(self) -> vtkAbstractCellLinks
| C++: virtual vtkAbstractCellLinks *GetLinks()
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Convenience method returns largest cell size in dataset. This is
| generally used to allocate memory for supporting data structures.
| THIS METHOD IS THREAD SAFE
|
| GetMaxSpatialDimension(...)
| GetMaxSpatialDimension(self) -> int
| C++: int GetMaxSpatialDimension() override;
|
| Get the maximum/minimum spatial dimensionality of the data which
| is the maximum/minimum dimension of all cells.
|
| @warning This method MUST be overridden for performance reasons.
| Default implementation is very inefficient.
|
| GetMinSpatialDimension(...)
| GetMinSpatialDimension(self) -> int
| C++: int GetMinSpatialDimension() override;
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| This method always returns 0, as there are no cells in a
| `vtkPointSet`.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetPointCells(...)
| GetPointCells(self, ptId:int, cellIds:vtkIdList) -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
| override;
|
| Topological inquiry to get cells using point. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| HasAnyBlankCells(...)
| HasAnyBlankCells(self) -> bool
| C++: bool HasAnyBlankCells() override;
|
| Returns true if one or more cells are blanked, false otherwise.
|
| HasAnyGhostCells(...)
| HasAnyGhostCells(self) -> bool
| C++: bool HasAnyGhostCells()
|
| Returns true if one or more cells are ghost, false otherwise.
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Standard vtkDataSet API methods. See vtkDataSet for more
| information.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsCellGhost(...)
| IsCellGhost(self, cellId:int) -> int
| C++: unsigned char IsCellGhost(vtkIdType cellId)
|
| Return non-zero value if specified cell is a ghost cell. These
| methods should be called only after the dimensions of the grid
| are set.
|
| IsCellVisible(...)
| IsCellVisible(self, cellId:int) -> int
| C++: unsigned char IsCellVisible(vtkIdType cellId)
|
| Return non-zero value if specified cell is visible. These methods
| should be called only after the dimensions of the grid are set.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkExplicitStructuredGrid
| C++: vtkExplicitStructuredGrid *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkExplicitStructuredGrid
| C++: static vtkExplicitStructuredGrid *SafeDownCast(
| vtkObjectBase *o)
|
| SetCells(...)
| SetCells(self, _arg:vtkCellArray) -> None
| C++: virtual void SetCells(vtkCellArray *_arg)
|
| Set/Get the cell array defining hexahedron.
|
| SetDimensions(...)
| SetDimensions(self, i:int, j:int, k:int) -> None
| C++: void SetDimensions(int i, int j, int k)
| SetDimensions(self, dim:[int, int, int]) -> None
| C++: void SetDimensions(int dim[3])
|
| Set/Get the dimensions of this structured dataset in term of
| number of points along each direction. This is just a convenience
| method which calls Set/GetExtent internally.
|
| SetExtent(...)
| SetExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int, z1:int)
| -> None
| C++: void SetExtent(int x0, int x1, int y0, int y1, int z0,
| int z1)
| SetExtent(self, extent:[int, int, int, int, int, int]) -> None
| C++: void SetExtent(int extent[6])
|
| Set/Get the extent of this structured dataset in term of number
| of points along each direction. Setting the extent will reset the
| internal CellArray and Links and a correctly sized cell array
| will be created. The Extent is stored in the order (X, Y, Z).
|
| SetFacesConnectivityFlagsArrayName(...)
| SetFacesConnectivityFlagsArrayName(self, _arg:str) -> None
| C++: virtual void SetFacesConnectivityFlagsArrayName(
| const char *_arg)
|
| Set/Get the name of the faces connectivity flags array.
|
| SetLinks(...)
| SetLinks(self, _arg:vtkAbstractCellLinks) -> None
| C++: virtual void SetLinks(vtkAbstractCellLinks *_arg)
|
| Set/Get the links that you created possibly without using
| BuildLinks.
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| UnBlankCell(...)
| UnBlankCell(self, cellId:int) -> None
| C++: void UnBlankCell(vtkIdType cellId)
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkExplicitStructuredGrid:
|
| __this__
| Pointer to the C++ object.
|
| cells
| read-write, calls GetCells/SetCells
|
| data_dimension
| read-only, calls GetDataDimension
|
| data_object_type
| read-only, calls GetDataObjectType
|
| extent
| read-write, calls GetExtent/SetExtent
|
| extent_type
| read-only, calls GetExtentType
|
| faces_connectivity_flags_array_name
| read-write, calls GetFacesConnectivityFlagsArrayName/SetFacesConnectivityFlagsArrayName
|
| links
| read-write, calls GetLinks/SetLinks
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| max_spatial_dimension
| read-only, calls GetMaxSpatialDimension
|
| min_spatial_dimension
| read-only, calls GetMinSpatialDimension
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkExplicitStructuredGrid:
|
| __vtkname__ = 'vtkExplicitStructuredGrid'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| BuildCellLocator(...)
| BuildCellLocator(self) -> None
| C++: void BuildCellLocator()
|
| Build the cell locator. In a multi-threaded environment, call
| this method in a single thread before using FindCell().
|
| BuildLocator(...)
| BuildLocator(self) -> None
| C++: void BuildLocator()
|
| BuildPointLocator(...)
| BuildPointLocator(self) -> None
| C++: void BuildPointLocator()
|
| Build the internal point locator . In a multi-threaded
| environment, call this method in a single thread before using
| FindCell() or FindPoint().
|
| ComputeBounds(...)
| ComputeBounds(self) -> None
| C++: void ComputeBounds() override;
|
| Compute the (X, Y, Z) bounds of the data.
|
| EditableOff(...)
| EditableOff(self) -> None
| C++: virtual void EditableOff()
|
| EditableOn(...)
| EditableOn(self) -> None
| C++: virtual void EditableOn()
|
| ExtendedNew(...)
| ExtendedNew() -> vtkPointSet
| C++: static vtkPointSet *ExtendedNew()
|
| FindCell(...)
| FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int,
| tol2:float, subId:int, pcoords:[float, float, float],
| weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
| FindCell(self, x:[float, float, float], cell:vtkCell,
| gencell:vtkGenericCell, cellId:int, tol2:float, subId:int,
| pcoords:[float, float, float], weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkGenericCell *gencell, vtkIdType cellId, double tol2,
| int &subId, double pcoords[3], double *weights) override;
|
| Locate cell based on global coordinate x and tolerance squared.
| If cell and cellId is non-nullptr, then search starts from this
| cell and looks at immediate neighbors. Returns cellId >= 0 if
| inside, < 0 otherwise. The parametric coordinates are provided
| in pcoords[3]. The interpolation weights are returned in
| weights[]. (The number of weights is equal to the number of
| points in the found cell). Tolerance is used to control how close
| the point is to be considered "in" the cell. THIS METHOD IS NOT
| THREAD SAFE.
|
| FindPoint(...)
| FindPoint(self, x:[float, float, float]) -> int
| C++: vtkIdType FindPoint(double x[3]) override;
|
| GetCellLocator(...)
| GetCellLocator(self) -> vtkAbstractCellLocator
| C++: virtual vtkAbstractCellLocator *GetCellLocator()
|
| GetEditable(...)
| GetEditable(self) -> bool
| C++: virtual bool GetEditable()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Get MTime which also considers its vtkPoints MTime.
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| See vtkDataSet for additional information.
|
| GetPoint(...)
| GetPoint(self, ptId:int, x:[float, float, float]) -> None
| C++: void GetPoint(vtkIdType ptId, double x[3]) override;
| GetPoint(self, ptId:int) -> (float, float, float)
| C++: double *GetPoint(vtkIdType ptId) override;
|
| Copy point coordinates into user provided array x[3] for
| specified point id. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetPointLocator(...)
| GetPointLocator(self) -> vtkAbstractPointLocator
| C++: virtual vtkAbstractPointLocator *GetPointLocator()
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints() override;
|
| If the subclass has (implicit/explicit) points, then return them.
| Otherwise, create a vtkPoints object and return that.
|
| DO NOT MODIFY THE RETURNED POINTS OBJECT.
|
| NewCellIterator(...)
| NewCellIterator(self) -> vtkCellIterator
| C++: vtkCellIterator *NewCellIterator() override;
|
| Return an iterator that traverses the cells in this data set.
|
| SetCellLocator(...)
| SetCellLocator(self, __a:vtkAbstractCellLocator) -> None
| C++: virtual void SetCellLocator(vtkAbstractCellLocator *)
|
| Set / get an instance of vtkAbstractCellLocator which may be used
| when a vtkCellLocatorStrategy is used during a FindCell()
| operation.
|
| SetEditable(...)
| SetEditable(self, _arg:bool) -> None
| C++: virtual void SetEditable(bool _arg)
|
| Specify whether this dataset is editable after creation. Meaning,
| once the points and cells are defined, can the dataset be
| incrementally modified. By default, this dataset is non-editable
| (i.e., "static") after construction. The reason for this is
| performance: cell links and locators can be built (and destroyed)
| much faster is it is known that the data is static (see
| vtkStaticCellLinks, vtkStaticPointLocator, vtkStaticCellLocator).
|
| SetPointLocator(...)
| SetPointLocator(self, __a:vtkAbstractPointLocator) -> None
| C++: virtual void SetPointLocator(vtkAbstractPointLocator *)
|
| Set / get an instance of vtkAbstractPointLocator which is used to
| support the FindPoint() and FindCell() methods. By default a
| vtkStaticPointLocator is used, unless the class is set as
| Editable, in which case a vtkPointLocator is used.
|
| SetPoints(...)
| SetPoints(self, __a:vtkPoints) -> None
| C++: virtual void SetPoints(vtkPoints *)
|
| Specify point array to define point coordinates.
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: void Squeeze() override;
|
| Reclaim any unused memory.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Overwritten to handle the data/locator loop
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| cell_locator
| read-write, calls GetCellLocator/SetCellLocator
|
| editable
| read-write, calls GetEditable/SetEditable
|
| m_time
| read-only, calls GetMTime
|
| point_locator
| read-write, calls GetPointLocator/SetPointLocator
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| AllocateCellGhostArray(...)
| AllocateCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocateCellGhostArray()
|
| Allocate ghost array for cells.
|
| AllocatePointGhostArray(...)
| AllocatePointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocatePointGhostArray()
|
| Allocate ghost array for points.
|
| CheckAttributes(...)
| CheckAttributes(self) -> int
| C++: int CheckAttributes()
|
| This method checks to see if the cell and point attributes match
| the geometry. Many filters will crash if the number of tuples in
| an array is less than the number of points/cells. This method
| returns 1 if there is a mismatch, and 0 if everything is ok. It
| prints an error if an array is too short, and a warning if an
| array is too long.
|
| CopyAttributes(...)
| CopyAttributes(self, ds:vtkDataSet) -> None
| C++: virtual void CopyAttributes(vtkDataSet *ds)
|
| Copy the attributes associated with the specified dataset to this
| instance of vtkDataSet. THIS METHOD IS NOT THREAD SAFE.
|
| FindAndGetCell(...)
| FindAndGetCell(self, x:[float, float, float], cell:vtkCell,
| cellId:int, tol2:float, subId:int, pcoords:[float, float,
| float], weights:[float, ...]) -> vtkCell
| C++: virtual vtkCell *FindAndGetCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights)
|
| Locate the cell that contains a point and return the cell. Also
| returns the subcell id, parametric coordinates and weights for
| subsequent interpolation. This method combines the derived class
| methods int FindCell and vtkCell *GetCell. Derived classes may
| provide a more efficient implementation. See for example
| vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return a pointer to the geometry bounding box in the form
| (xmin,xmax, ymin,ymax, zmin,zmax). THIS METHOD IS NOT THREAD
| SAFE.
|
| GetCellData(...)
| GetCellData(self) -> vtkCellData
| C++: vtkCellData *GetCellData()
|
| Return a pointer to this dataset's cell data. THIS METHOD IS
| THREAD SAFE
|
| GetCellGhostArray(...)
| GetCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellGhostArray()
|
| Get the array that defines the ghost type of each cell. We cache
| the pointer to the array to save a lookup involving string
| comparisons
|
| GetCellNumberOfFaces(...)
| GetCellNumberOfFaces(self, cellId:int, cellType:int,
| cell:vtkGenericCell) -> int
| C++: virtual int GetCellNumberOfFaces(vtkIdType cellId,
| unsigned char &cellType, vtkGenericCell *cell)
|
| Get the number of faces of a cell.
|
| Most of the times extracting the number of faces requires only
| extracting the cell type. However, for some cell types, the
| number of faces is not constant. For example, a convex point set
| cell can have a different number of faces for each cell. That's
| why this method requires the cell id and the dataset.
|
| GetCellTypes(...)
| GetCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetCellTypes(vtkCellTypes *types)
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: double *GetCenter()
| GetCenter(self, center:[float, float, float]) -> None
| C++: void GetCenter(double center[3])
|
| Get the center of the bounding box. THIS METHOD IS NOT THREAD
| SAFE.
|
| GetDistinctCellTypes(...)
| GetDistinctCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetDistinctCellTypes(vtkCellTypes *types)
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset 5 triangles, 3 lines, and
| 100 hexahedra would result a list of three entries, corresponding
| to the types VTK_TRIANGLE, VTK_LINE, and VTK_HEXAHEDRON. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetGhostArray(int type) override;
|
| Returns the ghost array for the given type (point or cell). Takes
| advantage of the cache with the pointer to the array to save a
| string comparison.
|
| GetLength(...)
| GetLength(self) -> float
| C++: double GetLength()
|
| Return the length of the diagonal of the bounding box. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Return the squared length of the diagonal of the bounding box.
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetMeshMTime(...)
| GetMeshMTime(self) -> int
| C++: virtual vtkMTimeType GetMeshMTime()
|
| Abstract method which return the mesh (geometry/topology)
| modification time. This time is different from the usual MTime
| which also takes into account the modification of data arrays.
| This function can be used to track the changes on the mesh
| separately from the data arrays (eg. static mesh over time with
| transient data). The default implementation returns the MTime. It
| is up to subclasses to provide a better approach.
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| GetPointData(...)
| GetPointData(self) -> vtkPointData
| C++: vtkPointData *GetPointData()
|
| Return a pointer to this dataset's point data. THIS METHOD IS
| THREAD SAFE
|
| GetPointGhostArray(...)
| GetPointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetPointGhostArray()
|
| Gets the array that defines the ghost type of each point. We
| cache the pointer to the array to save a lookup involving string
| comparisons
|
| GetScalarRange(...)
| GetScalarRange(self, range:[float, float]) -> None
| C++: virtual void GetScalarRange(double range[2])
| GetScalarRange(self) -> (float, float)
| C++: double *GetScalarRange()
|
| Convenience method to get the range of the first component (and
| only the first component) of any scalars in the data set. If the
| data has both point data and cell data, it returns the (min/max)
| range of combined point and cell data. If there are no point or
| cell scalars the method will return (0,1). Note: It might be
| necessary to call Update to create or refresh the scalars before
| calling this method. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| HasAnyBlankPoints(...)
| HasAnyBlankPoints(self) -> bool
| C++: virtual bool HasAnyBlankPoints()
|
| Returns 1 if there are any blanking points 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyGhostPoints(...)
| HasAnyGhostPoints(self) -> bool
| C++: bool HasAnyGhostPoints()
|
| Returns 1 if there are any ghost points 0 otherwise.
|
| SetCellOrderAndRationalWeights(...)
| SetCellOrderAndRationalWeights(self, cellId:int,
| cell:vtkGenericCell) -> None
| C++: void SetCellOrderAndRationalWeights(vtkIdType cellId,
| vtkGenericCell *cell)
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| cell_ghost_array
| read-only, calls GetCellGhostArray
|
| length2
| read-only, calls GetLength2
|
| mesh_m_time
| read-only, calls GetMeshMTime
|
| point_ghost_array
| read-only, calls GetPointGhostArray
|
| scalar_range
| read-only, calls GetScalarRange
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| CELL_DATA_FIELD = 2
|
| DATA_OBJECT_FIELD = 0
|
| FieldDataType = <class 'vtkmodules.vtkCommonDataModel.vtkDataSet.Field...
|
| POINT_DATA_FIELD = 1
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class PointGrid(_PointSet)
| PointGrid(*args, **kwargs) -> '_T'
|
| Class in common with structured and unstructured grids.
|
| Method resolution order:
| PointGrid
| _PointSet
| pyvista.core.dataset.DataSet
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| builtins.object
|
| Methods defined here:
|
| __init__(self, *args, **kwargs) -> 'None'
| Initialize the point grid.
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| plot_curvature(self: 'Self', curv_type='mean', **kwargs)
| Plot the curvature of the external surface of the grid.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| One of the following strings indicating curvature types.
| - ``'mean'``
| - ``'gaussian'``
| - ``'maximum'``
| - ``'minimum'``
|
| **kwargs : dict, optional
| Optional keyword arguments. See :func:`pyvista.plot`.
|
| Returns
| -------
| list
| Camera position, focal point, and view up. Returned when
| ``return_cpos`` is ``True``.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from _PointSet:
|
| center_of_mass(self, scalars_weight: 'bool' = False) -> 'NumpyArray[float]'
| Return the coordinates for the center of mass of the mesh.
|
| Parameters
| ----------
| scalars_weight : bool, default: False
| Flag for using the mesh scalars as weights.
|
| Returns
| -------
| numpy.ndarray
| Coordinates for the center of mass.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 1, 1))
| >>> mesh.center_of_mass()
| array([1., 1., 1.])
|
| points_to_double(self) -> 'Self'
| Convert the points datatype to double precision.
|
| Returns
| -------
| pyvista.PointSet
| Pointset with points in double precision.
|
| Notes
| -----
| This operates in place.
|
| Examples
| --------
| Create a mesh that has points of the type ``float32`` and
| convert the points to ``float64``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.points.dtype
| dtype('float32')
| >>> _ = mesh.points_to_double()
| >>> mesh.points.dtype
| dtype('float64')
|
| remove_cells(self, ind: 'VectorLike[bool] | VectorLike[int]', inplace: 'bool' = False) -> '_PointSet'
| Remove cells.
|
| Parameters
| ----------
| ind : VectorLike[int] | VectorLike[bool]
| Cell indices to be removed. The array can also be a
| boolean array of the same size as the number of cells.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| Returns
| -------
| pyvista.DataSet
| Same type as the input, but with the specified cells
| removed.
|
| See Also
| --------
| :ref:`ghost_cells_example`
|
| Examples
| --------
| Remove 20 cells from an unstructured grid.
|
| >>> from pyvista import examples
| >>> import pyvista as pv
| >>> hex_mesh = pv.read(examples.hexbeamfile)
| >>> removed = hex_mesh.remove_cells(range(10, 20))
| >>> removed.plot(color='lightblue', show_edges=True, line_width=3)
|
| shallow_copy(self, to_copy: 'DataSet') -> 'None'
| Create a shallow copy from a different dataset into this one.
|
| This method mutates this dataset and returns ``None``.
|
| Parameters
| ----------
| to_copy : pyvista.DataSet
| Data object to perform the shallow copy from.
|
| translate(self: 'Self', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False)
| Translate the mesh.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats of cartesian values to translate the mesh with.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed. This is
| only valid when not updating in place.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PointSet
| Translated pointset.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=True)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __repr__(self: 'Self') -> 'str'
| Return the object representation.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| __str__(self: 'Self') -> 'str'
| Return the object string representation.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
class PointSet(_PointSet, vtkmodules.vtkCommonDataModel.vtkPointSet)
| PointSet(*args, **kwargs) -> '_T'
|
| Concrete class for storing a set of points.
|
| This is a concrete class representing a set of points that specifies the
| interface for datasets that explicitly use "point" arrays to represent
| geometry. This class is useful for improving the performance of filters on
| point clouds, but not plotting.
|
| For further details see :vtk:`vtkPointSet`.
|
| Parameters
| ----------
| var_inp : :vtk:`vtkPointSet`, MatrixLike[float], optional
| Flexible input type. Can be a :vtk:`vtkPointSet`, in which case
| this PointSet object will be copied if ``deep=True`` and will
| be a shallow copy if ``deep=False``.
|
| List, numpy array, or sequence containing point locations. Must be an
| ``(N, 3)`` array of points.
|
| deep : bool, default: False
| Whether to copy the input ``points``, or to create a PointSet from them
| without copying them. Setting ``deep=True`` ensures that the original
| arrays can be modified outside the mesh without affecting the
| mesh.
|
| force_float : bool, default: True
| Casts the datatype to ``float32`` if points datatype is non-float. Set
| this to ``False`` to allow non-float types, though this may lead to
| truncation of intermediate floats when transforming datasets.
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| Create a simple point cloud of 10 points from a numpy array.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> rng = np.random.default_rng(seed=0)
| >>> points = rng.random((10, 3))
| >>> pset = pv.PointSet(points)
|
| Plot the pointset. Note: this casts to a :class:`pyvista.PolyData`
| internally when plotting.
|
| >>> pset.plot(point_size=10)
|
| Method resolution order:
| PointSet
| _PointSet
| pyvista.core.dataset.DataSet
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkPointSet
| vtkmodules.vtkCommonDataModel.vtkDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, var_inp=None, deep: 'bool' = False, force_float: 'bool' = True, *, validate: 'bool | _NestedMeshValidationFields' = False) -> 'None'
| Initialize the pointset.
|
| __repr__(self)
| Return the standard representation.
|
| __str__(self)
| Return the standard str representation.
|
| cast_to_polydata(self, deep: 'bool' = True)
| Cast this dataset to polydata.
|
| Parameters
| ----------
| deep : bool, deep: True
| Whether to copy the pointset points, or to create a PolyData
| without copying them. Setting ``deep=True`` ensures that the
| original arrays can be modified outside the PolyData without
| affecting the PolyData.
|
| Returns
| -------
| pyvista.PolyData
| PointSet cast to a ``pyvista.PolyData``.
|
| cast_to_unstructured_grid(self) -> 'pv.UnstructuredGrid'
| Cast this dataset to :class:`pyvista.UnstructuredGrid`.
|
| A deep copy of the points and point data is made.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast to a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PointSet` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cloud_dark_matter()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PointSet'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_data_to_point_data(self, *args, **kwargs)
| Raise PointSets do not have cells.
|
| cell_validator(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| contour(self, *args, **kwargs)
| Raise dimension reducing operations are not supported.
|
| decimate_boundary(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False) from pyvista.core.filters.data_set.DataSetFilters
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1) from pyvista.core.filters.data_set.DataSetFilters
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_geometry(self, *args, **kwargs)
| Raise extract geometry are not supported.
|
| ..deprecated:: 0.47
|
| extract_surface(self, *args, **kwargs)
| Raise extract surface are not supported.
|
| find_cells_along_line(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_data_to_cell_data(self, *args, **kwargs)
| Raise PointSets do not have cells.
|
| point_is_inside_cell(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| remove_cells(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| separate_cells(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| shrink(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| slice(self, *args, **kwargs)
| Raise dimension reducing operations are not supported.
|
| slice_along_axis(self, *args, **kwargs)
| Raise dimension reducing operations are not supported.
|
| slice_along_line(self, *args, **kwargs)
| Raise dimension reducing operations are not supported.
|
| slice_implicit(self, *args, **kwargs)
| Raise dimension reducing operations are not supported.
|
| slice_orthogonal(self, *args, **kwargs)
| Raise dimension reducing operations are not supported.
|
| tessellate(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False) from pyvista.core.filters.data_set.DataSetFilters
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False) from pyvista.core.filters.data_set.DataSetFilters
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| triangulate(self, *args, **kwargs)
| Raise cell operations are not supported.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| area
| Return 0.0 since a PointSet has no area.
|
| volume
| Return 0.0 since a PointSet has no volume.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from _PointSet:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| center_of_mass(self, scalars_weight: 'bool' = False) -> 'NumpyArray[float]'
| Return the coordinates for the center of mass of the mesh.
|
| Parameters
| ----------
| scalars_weight : bool, default: False
| Flag for using the mesh scalars as weights.
|
| Returns
| -------
| numpy.ndarray
| Coordinates for the center of mass.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 1, 1))
| >>> mesh.center_of_mass()
| array([1., 1., 1.])
|
| points_to_double(self) -> 'Self'
| Convert the points datatype to double precision.
|
| Returns
| -------
| pyvista.PointSet
| Pointset with points in double precision.
|
| Notes
| -----
| This operates in place.
|
| Examples
| --------
| Create a mesh that has points of the type ``float32`` and
| convert the points to ``float64``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.points.dtype
| dtype('float32')
| >>> _ = mesh.points_to_double()
| >>> mesh.points.dtype
| dtype('float64')
|
| shallow_copy(self, to_copy: 'DataSet') -> 'None'
| Create a shallow copy from a different dataset into this one.
|
| This method mutates this dataset and returns ``None``.
|
| Parameters
| ----------
| to_copy : pyvista.DataSet
| Data object to perform the shallow copy from.
|
| translate(self: 'Self', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False)
| Translate the mesh.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats of cartesian values to translate the mesh with.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed. This is
| only valid when not updating in place.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PointSet
| Translated pointset.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=True)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| BuildCellLocator(...)
| BuildCellLocator(self) -> None
| C++: void BuildCellLocator()
|
| Build the cell locator. In a multi-threaded environment, call
| this method in a single thread before using FindCell().
|
| BuildLocator(...)
| BuildLocator(self) -> None
| C++: void BuildLocator()
|
| BuildPointLocator(...)
| BuildPointLocator(self) -> None
| C++: void BuildPointLocator()
|
| Build the internal point locator . In a multi-threaded
| environment, call this method in a single thread before using
| FindCell() or FindPoint().
|
| ComputeBounds(...)
| ComputeBounds(self) -> None
| C++: void ComputeBounds() override;
|
| Compute the (X, Y, Z) bounds of the data.
|
| CopyStructure(...)
| CopyStructure(self, pd:vtkDataSet) -> None
| C++: void CopyStructure(vtkDataSet *pd) override;
|
| Copy the geometric structure of an input point set object.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| EditableOff(...)
| EditableOff(self) -> None
| C++: virtual void EditableOff()
|
| EditableOn(...)
| EditableOn(self) -> None
| C++: virtual void EditableOn()
|
| ExtendedNew(...)
| ExtendedNew() -> vtkPointSet
| C++: static vtkPointSet *ExtendedNew()
|
| FindCell(...)
| FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int,
| tol2:float, subId:int, pcoords:[float, float, float],
| weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
| FindCell(self, x:[float, float, float], cell:vtkCell,
| gencell:vtkGenericCell, cellId:int, tol2:float, subId:int,
| pcoords:[float, float, float], weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkGenericCell *gencell, vtkIdType cellId, double tol2,
| int &subId, double pcoords[3], double *weights) override;
|
| Locate cell based on global coordinate x and tolerance squared.
| If cell and cellId is non-nullptr, then search starts from this
| cell and looks at immediate neighbors. Returns cellId >= 0 if
| inside, < 0 otherwise. The parametric coordinates are provided
| in pcoords[3]. The interpolation weights are returned in
| weights[]. (The number of weights is equal to the number of
| points in the found cell). Tolerance is used to control how close
| the point is to be considered "in" the cell. THIS METHOD IS NOT
| THREAD SAFE.
|
| FindPoint(...)
| FindPoint(self, x:[float, float, float]) -> int
| C++: vtkIdType FindPoint(double x[3]) override;
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated. The
| memory size returned is guaranteed to be greater than or equal to
| the memory required to represent the data (e.g., extra space in
| arrays, etc. are not included in the return value). THIS METHOD
| IS THREAD SAFE.
|
| GetCell(...)
| GetCell(self, __a:int) -> vtkCell
| C++: vtkCell *GetCell(vtkIdType) override;
| GetCell(self, __a:int, cell:vtkGenericCell) -> None
| C++: void GetCell(vtkIdType, vtkGenericCell *cell) override;
| GetCell(self, i:int, j:int, k:int) -> vtkCell
| C++: virtual vtkCell *GetCell(int i, int j, int k)
|
| This method always return a `vtkEmptyCell`, as there is no cell
| in a `vtkPointSet`.
|
| GetCellLocator(...)
| GetCellLocator(self) -> vtkAbstractCellLocator
| C++: virtual vtkAbstractCellLocator *GetCellLocator()
|
| GetCellPoints(...)
| GetCellPoints(self, __a:int, idList:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType, vtkIdList *idList) override;
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...),
| ptIds:vtkIdList) -> None
| C++: virtual void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts, vtkIdList *ptIds)
|
| Topological inquiry to get points defining cell. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| GetCellSize(...)
| GetCellSize(self, __a:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType) override;
|
| This method always returns 1, as all cells are point in a pure
| `vtkPointSet`.
|
| GetCellType(...)
| GetCellType(self, __a:int) -> int
| C++: int GetCellType(vtkIdType) override;
|
| This method always returns `VTK_EMPTY_CELL`, as there is no cell
| in a `vtkPointSet`.
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkPointSet
| C++: static vtkPointSet *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkPointSet
| C++: static vtkPointSet *GetData(vtkInformationVector *v, int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Standard vtkDataSet API methods. See vtkDataSet for more
| information.
|
| GetEditable(...)
| GetEditable(self) -> bool
| C++: virtual bool GetEditable()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Get MTime which also considers its vtkPoints MTime.
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Convenience method returns largest cell size in dataset. This is
| generally used to allocate memory for supporting data structures.
| THIS METHOD IS THREAD SAFE
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| This method always returns 0, as there are no cells in a
| `vtkPointSet`.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| See vtkDataSet for additional information.
|
| GetPoint(...)
| GetPoint(self, ptId:int, x:[float, float, float]) -> None
| C++: void GetPoint(vtkIdType ptId, double x[3]) override;
| GetPoint(self, ptId:int) -> (float, float, float)
| C++: double *GetPoint(vtkIdType ptId) override;
|
| Copy point coordinates into user provided array x[3] for
| specified point id. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetPointCells(...)
| GetPointCells(self, __a:int, idList:vtkIdList) -> None
| C++: void GetPointCells(vtkIdType, vtkIdList *idList) override;
|
| Topological inquiry to get cells using point. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| GetPointLocator(...)
| GetPointLocator(self) -> vtkAbstractPointLocator
| C++: virtual vtkAbstractPointLocator *GetPointLocator()
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints() override;
|
| If the subclass has (implicit/explicit) points, then return them.
| Otherwise, create a vtkPoints object and return that.
|
| DO NOT MODIFY THE RETURNED POINTS OBJECT.
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Reset to an empty state and free any memory.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewCellIterator(...)
| NewCellIterator(self) -> vtkCellIterator
| C++: vtkCellIterator *NewCellIterator() override;
|
| Return an iterator that traverses the cells in this data set.
|
| NewInstance(...)
| NewInstance(self) -> vtkPointSet
| C++: vtkPointSet *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkPointSet
| C++: static vtkPointSet *SafeDownCast(vtkObjectBase *o)
|
| SetCellLocator(...)
| SetCellLocator(self, __a:vtkAbstractCellLocator) -> None
| C++: virtual void SetCellLocator(vtkAbstractCellLocator *)
|
| Set / get an instance of vtkAbstractCellLocator which may be used
| when a vtkCellLocatorStrategy is used during a FindCell()
| operation.
|
| SetEditable(...)
| SetEditable(self, _arg:bool) -> None
| C++: virtual void SetEditable(bool _arg)
|
| Specify whether this dataset is editable after creation. Meaning,
| once the points and cells are defined, can the dataset be
| incrementally modified. By default, this dataset is non-editable
| (i.e., "static") after construction. The reason for this is
| performance: cell links and locators can be built (and destroyed)
| much faster is it is known that the data is static (see
| vtkStaticCellLinks, vtkStaticPointLocator, vtkStaticCellLocator).
|
| SetPointLocator(...)
| SetPointLocator(self, __a:vtkAbstractPointLocator) -> None
| C++: virtual void SetPointLocator(vtkAbstractPointLocator *)
|
| Set / get an instance of vtkAbstractPointLocator which is used to
| support the FindPoint() and FindCell() methods. By default a
| vtkStaticPointLocator is used, unless the class is set as
| Editable, in which case a vtkPointLocator is used.
|
| SetPoints(...)
| SetPoints(self, __a:vtkPoints) -> None
| C++: virtual void SetPoints(vtkPoints *)
|
| Specify point array to define point coordinates.
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: void Squeeze() override;
|
| Reclaim any unused memory.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Overwritten to handle the data/locator loop
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| __this__
| Pointer to the C++ object.
|
| cell_locator
| read-write, calls GetCellLocator/SetCellLocator
|
| data_object_type
| read-only, calls GetDataObjectType
|
| editable
| read-write, calls GetEditable/SetEditable
|
| m_time
| read-only, calls GetMTime
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| point_locator
| read-write, calls GetPointLocator/SetPointLocator
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| __vtkname__ = 'vtkPointSet'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| AllocateCellGhostArray(...)
| AllocateCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocateCellGhostArray()
|
| Allocate ghost array for cells.
|
| AllocatePointGhostArray(...)
| AllocatePointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocatePointGhostArray()
|
| Allocate ghost array for points.
|
| CheckAttributes(...)
| CheckAttributes(self) -> int
| C++: int CheckAttributes()
|
| This method checks to see if the cell and point attributes match
| the geometry. Many filters will crash if the number of tuples in
| an array is less than the number of points/cells. This method
| returns 1 if there is a mismatch, and 0 if everything is ok. It
| prints an error if an array is too short, and a warning if an
| array is too long.
|
| CopyAttributes(...)
| CopyAttributes(self, ds:vtkDataSet) -> None
| C++: virtual void CopyAttributes(vtkDataSet *ds)
|
| Copy the attributes associated with the specified dataset to this
| instance of vtkDataSet. THIS METHOD IS NOT THREAD SAFE.
|
| FindAndGetCell(...)
| FindAndGetCell(self, x:[float, float, float], cell:vtkCell,
| cellId:int, tol2:float, subId:int, pcoords:[float, float,
| float], weights:[float, ...]) -> vtkCell
| C++: virtual vtkCell *FindAndGetCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights)
|
| Locate the cell that contains a point and return the cell. Also
| returns the subcell id, parametric coordinates and weights for
| subsequent interpolation. This method combines the derived class
| methods int FindCell and vtkCell *GetCell. Derived classes may
| provide a more efficient implementation. See for example
| vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE.
|
| GenerateGhostArray(...)
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int])
| -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6])
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int],
| cellOnly:bool) -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6],
| bool cellOnly)
|
| Normally called by pipeline executives or algorithms only. This
| method computes the ghost arrays for a given dataset. The zeroExt
| argument specifies the extent of the region which ghost type = 0.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return a pointer to the geometry bounding box in the form
| (xmin,xmax, ymin,ymax, zmin,zmax). THIS METHOD IS NOT THREAD
| SAFE.
|
| GetCellBounds(...)
| GetCellBounds(self, cellId:int, bounds:[float, float, float,
| float, float, float]) -> None
| C++: virtual void GetCellBounds(vtkIdType cellId,
| double bounds[6])
|
| Get the bounds of the cell with cellId such that: 0 <= cellId <
| NumberOfCells. A subclass may be able to determine the bounds of
| cell without using an expensive GetCell() method. A default
| implementation is provided that actually uses a GetCell() call.
| This is to ensure the method is available to all datasets.
| Subclasses should override this method to provide an efficient
| implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetCellData(...)
| GetCellData(self) -> vtkCellData
| C++: vtkCellData *GetCellData()
|
| Return a pointer to this dataset's cell data. THIS METHOD IS
| THREAD SAFE
|
| GetCellGhostArray(...)
| GetCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellGhostArray()
|
| Get the array that defines the ghost type of each cell. We cache
| the pointer to the array to save a lookup involving string
| comparisons
|
| GetCellNeighbors(...)
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList) -> None
| C++: virtual void GetCellNeighbors(vtkIdType cellId,
| vtkIdList *ptIds, vtkIdList *cellIds)
|
| Topological inquiry to get all cells using list of points
| exclusive of cell specified (e.g., cellId). Note that the list
| consists of only cells that use ALL the points provided. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetCellNumberOfFaces(...)
| GetCellNumberOfFaces(self, cellId:int, cellType:int,
| cell:vtkGenericCell) -> int
| C++: virtual int GetCellNumberOfFaces(vtkIdType cellId,
| unsigned char &cellType, vtkGenericCell *cell)
|
| Get the number of faces of a cell.
|
| Most of the times extracting the number of faces requires only
| extracting the cell type. However, for some cell types, the
| number of faces is not constant. For example, a convex point set
| cell can have a different number of faces for each cell. That's
| why this method requires the cell id and the dataset.
|
| GetCellTypes(...)
| GetCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetCellTypes(vtkCellTypes *types)
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: double *GetCenter()
| GetCenter(self, center:[float, float, float]) -> None
| C++: void GetCenter(double center[3])
|
| Get the center of the bounding box. THIS METHOD IS NOT THREAD
| SAFE.
|
| GetDistinctCellTypes(...)
| GetDistinctCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetDistinctCellTypes(vtkCellTypes *types)
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset 5 triangles, 3 lines, and
| 100 hexahedra would result a list of three entries, corresponding
| to the types VTK_TRIANGLE, VTK_LINE, and VTK_HEXAHEDRON. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetGhostArray(int type) override;
|
| Returns the ghost array for the given type (point or cell). Takes
| advantage of the cache with the pointer to the array to save a
| string comparison.
|
| GetLength(...)
| GetLength(self) -> float
| C++: double GetLength()
|
| Return the length of the diagonal of the bounding box. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Return the squared length of the diagonal of the bounding box.
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetMaxSpatialDimension(...)
| GetMaxSpatialDimension(self) -> int
| C++: virtual int GetMaxSpatialDimension()
|
| Get the maximum/minimum spatial dimensionality of the data which
| is the maximum/minimum dimension of all cells.
|
| @warning This method MUST be overridden for performance reasons.
| Default implementation is very inefficient.
|
| GetMeshMTime(...)
| GetMeshMTime(self) -> int
| C++: virtual vtkMTimeType GetMeshMTime()
|
| Abstract method which return the mesh (geometry/topology)
| modification time. This time is different from the usual MTime
| which also takes into account the modification of data arrays.
| This function can be used to track the changes on the mesh
| separately from the data arrays (eg. static mesh over time with
| transient data). The default implementation returns the MTime. It
| is up to subclasses to provide a better approach.
|
| GetMinSpatialDimension(...)
| GetMinSpatialDimension(self) -> int
| C++: virtual int GetMinSpatialDimension()
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| GetPointData(...)
| GetPointData(self) -> vtkPointData
| C++: vtkPointData *GetPointData()
|
| Return a pointer to this dataset's point data. THIS METHOD IS
| THREAD SAFE
|
| GetPointGhostArray(...)
| GetPointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetPointGhostArray()
|
| Gets the array that defines the ghost type of each point. We
| cache the pointer to the array to save a lookup involving string
| comparisons
|
| GetScalarRange(...)
| GetScalarRange(self, range:[float, float]) -> None
| C++: virtual void GetScalarRange(double range[2])
| GetScalarRange(self) -> (float, float)
| C++: double *GetScalarRange()
|
| Convenience method to get the range of the first component (and
| only the first component) of any scalars in the data set. If the
| data has both point data and cell data, it returns the (min/max)
| range of combined point and cell data. If there are no point or
| cell scalars the method will return (0,1). Note: It might be
| necessary to call Update to create or refresh the scalars before
| calling this method. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| HasAnyBlankCells(...)
| HasAnyBlankCells(self) -> bool
| C++: virtual bool HasAnyBlankCells()
|
| Returns 1 if there are any blanking cells 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyBlankPoints(...)
| HasAnyBlankPoints(self) -> bool
| C++: virtual bool HasAnyBlankPoints()
|
| Returns 1 if there are any blanking points 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyGhostCells(...)
| HasAnyGhostCells(self) -> bool
| C++: bool HasAnyGhostCells()
|
| Returns 1 if there are any ghost cells 0 otherwise.
|
| HasAnyGhostPoints(...)
| HasAnyGhostPoints(self) -> bool
| C++: bool HasAnyGhostPoints()
|
| Returns 1 if there are any ghost points 0 otherwise.
|
| SetCellOrderAndRationalWeights(...)
| SetCellOrderAndRationalWeights(self, cellId:int,
| cell:vtkGenericCell) -> None
| C++: void SetCellOrderAndRationalWeights(vtkIdType cellId,
| vtkGenericCell *cell)
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| cell_ghost_array
| read-only, calls GetCellGhostArray
|
| length2
| read-only, calls GetLength2
|
| max_spatial_dimension
| read-only, calls GetMaxSpatialDimension
|
| mesh_m_time
| read-only, calls GetMeshMTime
|
| min_spatial_dimension
| read-only, calls GetMinSpatialDimension
|
| point_ghost_array
| read-only, calls GetPointGhostArray
|
| scalar_range
| read-only, calls GetScalarRange
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| CELL_DATA_FIELD = 2
|
| DATA_OBJECT_FIELD = 0
|
| FieldDataType = <class 'vtkmodules.vtkCommonDataModel.vtkDataSet.Field...
|
| POINT_DATA_FIELD = 1
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: virtual void Crop(const int *updateExtent)
|
| This method crops the data object (if necessary) so that the
| extent matches the update extent.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: virtual int GetExtentType()
|
| The ExtentType will be left as VTK_PIECES_EXTENT for data objects
| such as vtkPolyData and vtkUnstructuredGrid. The ExtentType will
| be changed to VTK_3D_EXTENT for data objects with 3D structure
| such as vtkImageData (and its subclass vtkStructuredPoints),
| vtkRectilinearGrid, and vtkStructuredGrid. The default is the
| have an extent in pieces, with only one piece (no streaming
| possible).
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| extent_type
| read-only, calls GetExtentType
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class PolyData(_PointSet, pyvista.core.filters.poly_data.PolyDataFilters, vtkmodules.vtkCommonDataModel.vtkPolyData)
| PolyData(*args, **kwargs) -> '_T'
|
| Dataset consisting of surface geometry (e.g. vertices, lines, and polygons).
|
| The surface geometry is defined by its :attr:`~pyvista.DataSet.points` and four separate
| cell connectivity arrays:
|
| - :attr:`verts` for 0-dimensional :attr:`~pyvista.CellType.VERTEX` and
| :attr:`~pyvista.CellType.POLY_VERTEX` cells.
| - :attr:`lines` for 1-dimensional :attr:`~pyvista.CellType.LINE` and
| :attr:`~pyvista.CellType.POLY_LINE` cells.
| - :attr:`faces` for 2-dimensional :attr:`~pyvista.CellType.TRIANGLE`,
| :attr:`~pyvista.CellType.QUAD`, and :attr:`~pyvista.CellType.POLYGON` cells.
| - :attr:`strips` for 2-dimensional :attr:`~pyvista.CellType.TRIANGLE_STRIP` cells.
|
| Cell types can be mixed, and any combination of cell connectivity array(s) may be specified.
|
| :class:`~pyvista.PolyData` can be initialized in several ways:
|
| - Create an empty mesh
| - Initialize from a :vtk:`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 :attr:`verts` connectivity is
| populated by default, and each point is automatically associated with a single
| :attr:`~pyvista.CellType.VERTEX` to create a point cloud where :attr:`n_verts` equals
| :attr:`~pyvista.DataSet.n_points`.
|
| Parameters
| ----------
| var_inp : :vtk:`vtkPolyData`, str, sequence, optional
| Flexible input type. Can be a :vtk:`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``.
|
| faces : CellArrayLike, optional
| Connectivity of polygonal :attr:`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.
|
| lines : CellArrayLike, optional
| Connectivity of :attr:`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]``.
|
| strips : CellArrayLike optional
| Connectivity of triangle :attr:`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]``.
|
| deep : bool, 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_ext : str, 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_float : bool, 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.
|
| verts : CellArrayLike, optional
| The :attr:`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.
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| pyvista.PolyData.from_regular_faces
| pyvista.PolyData.from_irregular_faces
|
| Examples
| --------
| >>> 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 :vtk:`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')
|
| 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')
|
| Construct a mesh reusing the ``faces`` ``pv.CellArray`` from another
| mesh. The VTK methods ``GetPolys``, ``GetLines``, ``GetStrips``, and
| ``GetVerts`` return the underlying ``CellArray``s 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()
|
| See :ref:`create_poly_example` for more examples.
|
| Method resolution order:
| PolyData
| _PointSet
| pyvista.core.dataset.DataSet
| pyvista.core.filters.poly_data.PolyDataFilters
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkPolyData
| vtkmodules.vtkCommonDataModel.vtkPointSet
| vtkmodules.vtkCommonDataModel.vtkDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __and__(self, other_mesh)
| Compute boolean intersection of two meshes.
|
| __del__(self) -> 'None'
| Delete the object.
|
| __init__(self, var_inp: '_vtk.vtkPolyData | str | Path | MatrixLike[float] | None' = None, faces: 'CellArrayLike | None' = None, lines: 'CellArrayLike | None' = None, strips: 'CellArrayLike | None' = None, deep: 'bool' = False, force_ext: 'str | None' = None, force_float: 'bool' = True, verts: 'CellArrayLike | None' = None, *, validate: 'bool | _NestedMeshValidationFields' = False) -> 'None'
| Initialize the polydata.
|
| __isub__(self, cutting_mesh)
| Compute boolean difference of two meshes and update this mesh.
|
| __or__(self, other_mesh)
| Compute boolean union of two meshes.
|
| __repr__(self) -> 'str'
| Return the standard representation.
|
| __str__(self) -> 'str'
| Return the standard str representation.
|
| __sub__(self, cutting_mesh)
| Compute boolean difference of two meshes.
|
| obbTree = <functools.cached_property object>
| Return the obbTree of the polydata.
|
| An obbTree is an object to generate oriented bounding box (OBB)
| trees. An oriented bounding box is a bounding box that does not
| necessarily line up along coordinate axes. The OBB tree is a
| hierarchical tree structure of such boxes, where deeper levels of OBB
| confine smaller regions of space.
|
| .. warning::
|
| This property is expensive to compute and is therefore cached. If the mesh's
| geometry is modified, the obb tree will no longer be valid.
|
| save(self, filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, recompute_normals: 'bool' = True, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Write a surface mesh to disk.
|
| Written file may be an ASCII or binary ply, stl, or vtk mesh
| file.
|
| Parameters
| ----------
| filename : str, Path
| Filename of mesh to be written. File type is inferred from
| the extension of the filename unless overridden with
| ftype. Can be one of many of the supported the following
| types (``'.ply'``, ``'.vtp'``, ``'.stl'``, ``'.vtk``, ``'.geo'``,
| ``'.obj'``, ``'.iv'``).
|
| binary : bool, default: True
| Writes the file as binary when ``True`` and ASCII when ``False``.
|
| texture : str, numpy.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'`` if the array
| contains an alpha channel (i.e. 4 component array), or
| as ``'RGB'`` if the array is just a 3 component array.
|
| .. note::
| This feature is only available when saving PLY files.
|
| recompute_normals : bool, default: True
| When ``True``, if ply or stl format is chosen, the face normals
| are computed in place to ensure the mesh is properly saved.
| Set this to ``False`` to save instead the already existing normal
| array in the PolyData.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. When
| the target extension dispatches to a built-in VTK writer or
| to the pickle path, passing any extra keyword arguments
| raises :class:`TypeError`.
|
| .. versionadded:: 0.48
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| Examples
| --------
| Save a mesh as a STL.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.save('my_mesh.stl') # doctest:+SKIP
|
| Save a mesh as a PLY.
|
| >>> sphere = pv.Sphere()
| >>> sphere.save('my_mesh.ply') # doctest:+SKIP
|
| Save a mesh as a PLY with a texture array. Here we also
| create a simple RGB array representing the texture.
|
| >>> import numpy as np
| >>> sphere = pv.Sphere()
| >>> texture = np.zeros((sphere.n_points, 3), np.uint8)
| >>> # Just the green channel is set as a repeatedly
| >>> # decreasing value
| >>> texture[:, 1] = np.arange(sphere.n_points)[::-1]
| >>> sphere.point_data['my_texture'] = texture
| >>> sphere.save('my_mesh.ply', texture='my_texture') # doctest:+SKIP
|
| Alternatively, provide just the texture array. This will be
| written to the file as ``'RGB'`` since it does not contain an
| alpha channel.
|
| >>> sphere.save('my_mesh.ply', texture=texture) # doctest:+SKIP
|
| Save a mesh as a VTK file.
|
| >>> sphere = pv.Sphere()
| >>> sphere.save('my_mesh.vtk') # doctest:+SKIP
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_irregular_faces(points: 'MatrixLike[float]', faces: 'Sequence[VectorLike[int]]')
| Alternate `pyvista.PolyData` convenience constructor from point and ragged face arrays.
|
| Parameters
| ----------
| points : MatrixLike[float]
| A (n_points, 3) array of points.
|
| faces : Sequence[VectorLike[int]]
| A sequence of face vectors containing point indices.
|
| Returns
| -------
| pyvista.PolyData
| The newly constructed mesh.
|
| See Also
| --------
| pyvista.PolyData.from_regular_faces
|
| Examples
| --------
| Construct a pyramid from five points and five faces
|
| >>> import pyvista as pv
| >>> points = [
| ... (1, 1, 0),
| ... (-1, 1, 0),
| ... (-1, -1, 0),
| ... (1, -1, 0),
| ... (0, 0, 1.61),
| ... ]
| >>> faces = [
| ... (0, 1, 2, 3),
| ... (0, 3, 4),
| ... (0, 4, 1),
| ... (3, 2, 4),
| ... (2, 1, 4),
| ... ]
| >>> pyramid = pv.PolyData.from_irregular_faces(points, faces)
| >>> pyramid.plot()
|
| from_regular_faces(points: 'MatrixLike[float]', faces: 'MatrixLike[int]', deep: 'bool' = False)
| Alternate `pyvista.PolyData` convenience constructor from point and regular face arrays.
|
| Parameters
| ----------
| points : MatrixLike[float]
| A (n_points, 3) array of points.
|
| faces : MatrixLike[int]
| A (n_faces, face_size) array of face indices. For a triangle mesh, ``face_size = 3``.
|
| deep : bool, default: False
| Whether to deep copy the faces array into :vtk:`vtkCellArray` connectivity data.
|
| Returns
| -------
| pyvista.PolyData
| The newly constructed mesh.
|
| See Also
| --------
| pyvista.PolyData.from_irregular_faces
|
| Examples
| --------
| Construct a tetrahedron from four triangles
|
| >>> import pyvista as pv
| >>> points = [[1.0, 1, 1], [-1, 1, -1], [1, -1, -1], [-1, -1, 1]]
| >>> faces = [[0, 1, 2], [1, 3, 2], [0, 2, 3], [0, 3, 1]]
| >>> tetra = pv.PolyData.from_regular_faces(points, faces)
| >>> tetra.plot()
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| cell_normals
| Return the cell normals.
|
| The active cell normals are returned if they exist. Otherwise, they
| are computed with :func:`~pyvista.PolyDataFilters.compute_normals`
| using the default options.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Array of cell normals.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.cell_normals
| pyvista_ndarray([[ 0.05413816, 0.00569015, 0.9985172 ],
| [ 0.05177207, 0.01682176, 0.9985172 ],
| [ 0.04714328, 0.02721819, 0.9985172 ],
| ...,
| [ 0.26742265, -0.02810723, -0.96316934],
| [ 0.1617585 , -0.01700151, -0.9866839 ],
| [ 0.1617585 , -0.01700151, -0.9866839 ]],
| shape=(1680, 3), dtype=float32)
|
| face_normals
| Return the cell normals.
|
| Alias to :func:`PolyData.cell_normals`.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Array of face normals.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.face_normals
| pyvista_ndarray([[ 0.05413816, 0.00569015, 0.9985172 ],
| [ 0.05177207, 0.01682176, 0.9985172 ],
| [ 0.04714328, 0.02721819, 0.9985172 ],
| ...,
| [ 0.26742265, -0.02810723, -0.96316934],
| [ 0.1617585 , -0.01700151, -0.9866839 ],
| [ 0.1617585 , -0.01700151, -0.9866839 ]],
| shape=(1680, 3), dtype=float32)
|
| is_all_triangles
| Return if all the faces of the :class:`pyvista.PolyData` are triangles.
|
| Returns
| -------
| bool
| ``True`` if all the faces of the :class:`pyvista.PolyData`
| are triangles and does not contain any vertices or lines.
|
| Examples
| --------
| Show a mesh from :func:`pyvista.Plane` is not composed of all
| triangles.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.is_all_triangles
| False
|
| Show that the mesh from :func:`pyvista.Sphere` contains only
| triangles.
|
| >>> sphere = pv.Sphere()
| >>> sphere.is_all_triangles
| True
|
| is_manifold
| Return if the mesh is manifold (no open edges).
|
| Examples
| --------
| Show a sphere is manifold.
|
| >>> import pyvista as pv
| >>> pv.Sphere().is_manifold
| True
|
| Show a plane is not manifold.
|
| >>> pv.Plane().is_manifold
| False
|
| n_faces
| Return the number of polygonal faces.
|
| This is the total number of :attr:`~pyvista.CellType.TRIANGLE`,
| :attr:`~pyvista.CellType.QUAD`, and :attr:`~pyvista.CellType.POLYGON` cells defined in
| the :attr:`faces` connectivity array.
|
| See Also
| --------
| faces
| n_verts, n_lines, n_strips
| Number of cells in other connectivity arrays.
| pyvista.DataSet.n_cells, pyvista.DataSet.n_points
| Number of total cells and points in this mesh.
|
| Examples
| --------
| Create a mesh with one face and one line
|
| >>> import pyvista as pv
| >>> mesh = pv.PolyData(
| ... [(0.0, 0, 0), (1, 0, 0), (0, 1, 0)],
| ... faces=[3, 0, 1, 2],
| ... lines=[2, 0, 1],
| ... )
| >>> mesh.n_cells, mesh.n_faces, mesh.n_lines
| (2, 1, 1)
|
| n_faces_strict
| Return the number of polygonal faces.
|
| .. deprecated:: 0.49
| Use :attr:`n_faces` instead. As of v0.49, :attr:`n_faces` returns the
| number of polygonal faces, identical to ``n_faces_strict``.
|
| n_lines
| Return the number of line cells.
|
| This is the total number of :attr:`~pyvista.CellType.LINE` and
| :attr:`~pyvista.CellType.POLY_LINE` cells defined in the :attr:`lines` connectivity array.
|
| See Also
| --------
| lines
| n_verts, n_faces, n_strips
| Number of cells in other connectivity arrays.
| pyvista.DataSet.n_cells, pyvista.DataSet.n_points
| Number of total cells and points in this mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Line()
| >>> mesh.n_lines, mesh.n_cells
| (1, 1)
|
| n_open_edges
| Return the number of open edges on this mesh.
|
| Examples
| --------
| Return the number of open edges on a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.n_open_edges
| 0
|
| Return the number of open edges on a plane.
|
| >>> plane = pv.Plane(i_resolution=1, j_resolution=1)
| >>> plane.n_open_edges
| 4
|
| n_strips
| Return the number of triangle strips.
|
| This is the total number of :attr:`~pyvista.CellType.TRIANGLE_STRIP` cells defined in the
| :attr:`strips` connectivity array.
|
| See Also
| --------
| strips
| n_verts, n_lines, n_faces
| Number of cells in other connectivity arrays.
| pyvista.DataSet.n_cells, pyvista.DataSet.n_points
| Number of total cells and points in this mesh.
|
| Examples
| --------
| Create a simple mesh with one triangle strip and return the
| number of triangles.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> vertices = np.array([[1.0, 0.0, 0.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])
| >>> strip = np.array([3, 0, 1, 2])
| >>> mesh = pv.PolyData(vertices, strips=strip)
| >>> mesh.n_strips, mesh.n_cells
| (1, 1)
|
| n_verts
| Return the number of vertex cells.
|
| This is the total number of :attr:`~pyvista.CellType.VERTEX` and
| :attr:`~pyvista.CellType.POLY_VERTEX` cells defined in the :attr:`verts` connectivity
| array.
|
| .. note::
| The number of vertices is separate and distinct from :attr:`~pyvista.DataSet.n_points`,
| as it's possible for :class:`~pyvista.PolyData` to have :attr:`~pyvista.DataSet.points`
| but no :attr:`verts`.
|
| See Also
| --------
| verts
| n_lines, n_faces, n_strips
| Number of cells in other connectivity arrays.
| pyvista.DataSet.n_cells, pyvista.DataSet.n_points
| Number of total cells and points in this mesh.
|
| Examples
| --------
| Create a simple mesh containing just two points and return the
| number of vertices and cells. By default, when constructing a PolyData with points but no
| cells, vertices are automatically created, one per point.
|
| >>> import pyvista as pv
| >>> mesh = pv.PolyData([[1.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.n_points, mesh.n_verts, mesh.n_cells
| (2, 2, 2)
|
| If any other cells are specified, these vertices are not created.
|
| >>> import pyvista as pv
| >>> mesh = pv.PolyData([[1.0, 0.0, 0.0], [1.0, 1.0, 1.0]], lines=[2, 0, 1])
| >>> mesh.n_points, mesh.n_verts, mesh.n_cells
| (2, 0, 1)
|
| point_normals
| Return the point normals.
|
| The active point normals are returned if they exist. Otherwise, they
| are computed with :func:`~pyvista.PolyDataFilters.compute_normals`
| using the default options.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Array of point normals.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.point_normals
| pyvista_ndarray([[ 0. , 0. , 1. ],
| [ 0. , 0. , -1. ],
| [ 0.10811902, 0. , 0.99413794],
| ...,
| [ 0.31232402, -0.06638652, -0.9476532 ],
| [ 0.21027282, -0.04469487, -0.97662055],
| [ 0.10575636, -0.02247921, -0.99413794]],
| shape=(842, 3), dtype=float32)
|
| volume
| Return the approximate volume of the dataset.
|
| This will throw a VTK error/warning if not a closed surface.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.volume
| 0.5183
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| faces
| Return the polygonal faces padded connectivity array.
|
| Like all padded VTK connectivity arrays, the array is structured as::
|
| [n0, p0_0, p0_1, ..., p0_n, n1, p1_0, p1_1, ..., p1_n, ...]
|
| where ``n0`` is the number of points in face 0, and ``pX_Y`` is the
| Y'th point in face X.
|
| Faces can be :attr:`~pyvista.CellType.TRIANGLE`, :attr:`~pyvista.CellType.QUAD`,
| or :attr:`~pyvista.CellType.POLYGON` cells.
|
| For example, a triangle and a quadrilateral might be represented as::
|
| [3, 0, 1, 2, 4, 0, 1, 3, 4]
|
| Where the two individual faces are ``[3, 0, 1, 2]`` and ``[4, 0, 1, 3, 4]``.
|
| Faces can also be set by assigning a :class:`~pyvista.CellArray` object
| instead of an array.
|
| Returns
| -------
| numpy.ndarray
| Array of face connectivity.
|
| See Also
| --------
| n_faces
| verts, lines, strips
| Padded connectivity arrays for other :class:`~pyvista.PolyData` cell types.
| pyvista.PolyData.regular_faces, pyvista.PolyData.irregular_faces
| Initialize :class:`~pyvista.PolyData` from faces.
|
| Notes
| -----
| The array returned cannot be modified in place and will raise a
| ``ValueError`` if attempted.
|
| You can, however, set the faces directly. See the example.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> plane = pv.Plane(i_resolution=2, j_resolution=2)
| >>> plane.faces
| array([4, 0, 1, 4, 3, 4, 1, 2, 5, 4, 4, 3, 4, 7, 6, 4, 4, 5, 8, 7])
|
| Note how the faces contain a "padding" indicating the number
| of points per face:
|
| >>> plane.faces.reshape(-1, 5)
| array([[4, 0, 1, 4, 3],
| [4, 1, 2, 5, 4],
| [4, 3, 4, 7, 6],
| [4, 4, 5, 8, 7]])
|
| Set the faces directly. The following example creates a simple plane
| with a single square faces and modifies it to have two triangles
| instead.
|
| >>> mesh = pv.Plane(i_resolution=1, j_resolution=1)
| >>> mesh.faces = [3, 0, 1, 2, 3, 3, 2, 1]
| >>> mesh.faces
| array([3, 0, 1, 2, 3, 3, 2, 1])
|
| irregular_faces
| Return a tuple of face arrays.
|
| Returns
| -------
| tuple[numpy.ndarray]
| Tuple of length n_faces where each element is an array of point
| indices for points in that face.
|
| See Also
| --------
| pyvista.PolyData.faces
| pyvista.PolyData.regular_faces
|
| Examples
| --------
| Get the face arrays of the five faces of a pyramid.
|
| >>> import pyvista as pv
| >>> pyramid = pv.Pyramid().extract_surface(algorithm=None)
| >>> pyramid.irregular_faces # doctest: +NORMALIZE_WHITESPACE
| (array([0, 4, 3], dtype=int32),
| array([0, 1, 4], dtype=int32),
| array([0, 3, 2, 1], dtype=int32),
| array([1, 2, 4], dtype=int32),
| array([2, 3, 4], dtype=int32))
|
| lines
| Return the lines connectivity array.
|
| Like all padded VTK connectivity arrays, the array is structured as::
|
| [n0, p0_0, p0_1, ..., p0_n, n1, p1_0, p1_1, ..., p1_n, ...]
|
| where ``n0`` is the number of points in line 0, and ``pX_Y`` is the
| Y'th point in line X.
|
| Lines can be a single :attr:`~pyvista.CellType.LINE` cell with connectivity
| to two points, or a :attr:`~pyvista.CellType.POLY_LINE` with connectivity
| to any number of points.
|
| For example, a single line and poly-line with five points might be represented as::
|
| [2, 0, 1, 5, 3, 2, 4, 6, 5]
|
| Where the two separate line cells are ``[2, 0, 1]`` and ``[5, 3, 2, 4, 6, 5]``.
|
| Lines can also be set by assigning a :class:`~pyvista.CellArray`.
|
| See Also
| --------
| n_lines
| verts, faces, strips
| Padded connectivity arrays for other :class:`~pyvista.PolyData` cell types.
|
| Examples
| --------
| Return the lines from a spline.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.random.default_rng().random((3, 3))
| >>> spline = pv.Spline(points, 10)
| >>> spline.lines
| array([10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| regular_faces
| Return a face array of point indices when all faces have the same size.
|
| Returns
| -------
| numpy.ndarray
| Array of face indices with shape (n_faces, face_size).
|
| See Also
| --------
| pyvista.PolyData.faces
|
| Raises
| ------
| ValueError
| If the mesh's faces are irregular.
|
| Examples
| --------
| Get the regular face array of a plane with 2x2 arrangement of cells
| as a 4x4 array.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane(i_resolution=2, j_resolution=2)
| >>> plane.regular_faces
| array([[0, 1, 4, 3],
| [1, 2, 5, 4],
| [3, 4, 7, 6],
| [4, 5, 8, 7]])
|
| strips
| Return or set the strips padded connectivity array.
|
| Like all padded VTK connectivity arrays, the array is structured as::
|
| [n0, p0_0, p0_1, ..., p0_n, n1, p1_0, p1_1, ..., p1_n, ...]
|
| where ``n0`` is the number of points in strip 0, and ``pX_Y`` is the
| Y'th point in strip X.
|
| Only the connectivity of :attr:`~pyvista.CellType.TRIANGLE_STRIP` cells is stored in this
| array.
|
| For example, two strips with one and two triangles, respectively, might look like::
|
| [3, 0, 1, 2, 4, 3, 4, 5, 6]
|
| Where the individual strips are ``[3, 0, 1, 2]`` and ``[4, 3, 4, 5, 6]``.
|
| Returns
| -------
| numpy.ndarray
| Array of strip indices.
|
| See Also
| --------
| n_strips
| verts, lines, faces
| Padded connectivity arrays for other :class:`~pyvista.PolyData` cell types.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> polygon = pv.Rectangle()
| >>> extruded = polygon.extrude((0, 0, 1), capping=False)
| >>> extruded.strips
| array([4, 0, 1, 4, 5, 4, 1, 2, 5, 6, 4, 2, 3, 6, 7, 4, 3, 0, 7, 4])
| >>> extruded.n_strips
| 4
|
| verts
| Return or set the vertex padded connectivity array.
|
| Like all padded VTK connectivity arrays, the array is structured as::
|
| [n0, p0_0, p0_1, ..., p0_n, n1, p1_0, p1_1, ..., p1_n, ...]
|
| where ``n0`` is the number of points in vertex 0, and ``pX_Y`` is the
| Y'th point in vertex X.
|
| Vertices can be a single :attr:`~pyvista.CellType.VERTEX` cell with connectivity
| to a single point, or a :attr:`~pyvista.CellType.POLY_VERTEX` with connectivity
| to multiple points.
|
| For example, a single vertex and poly-vertex with five points might be represented as::
|
| [1, 0, 5, 3, 2, 4, 1, 5]
|
| Where the two separate vertex cells are ``[1, 0]`` and ``[5, 3, 2, 4, 1, 5]``.
|
| See Also
| --------
| n_verts
| lines, faces, strips
| Padded connectivity arrays for other :class:`~pyvista.PolyData` cell types.
|
| Returns
| -------
| numpy.ndarray
| Array of vertex cell connectivity.
|
| Examples
| --------
| Create a point cloud polydata and return the vertex cells.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(seed=0)
| >>> points = rng.random((5, 3))
| >>> pdata = pv.PolyData(points)
| >>> pdata.verts
| array([1, 0, 1, 1, 1, 2, 1, 3, 1, 4])
|
| Set vertex cells. Note how the mesh plots both the surface
| mesh and the additional vertices in a single plot.
|
| >>> mesh = pv.Plane(i_resolution=3, j_resolution=3)
| >>> mesh.verts = np.vstack(
| ... (
| ... np.ones(mesh.n_points, dtype=np.int64),
| ... np.arange(mesh.n_points),
| ... )
| ... ).T
| >>> mesh.plot(
| ... color='lightblue',
| ... render_points_as_spheres=True,
| ... point_size=60,
| ... )
|
| Vertex cells can also be set to a ``CellArray``. The following
| ``verts`` assignment is equivalent to the one above.
|
| >>> mesh.verts = pv.CellArray.from_regular_cells(
| ... np.arange(mesh.n_points).reshape((-1, 1))
| ... )
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| ----------------------------------------------------------------------
| Methods inherited from _PointSet:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| center_of_mass(self, scalars_weight: 'bool' = False) -> 'NumpyArray[float]'
| Return the coordinates for the center of mass of the mesh.
|
| Parameters
| ----------
| scalars_weight : bool, default: False
| Flag for using the mesh scalars as weights.
|
| Returns
| -------
| numpy.ndarray
| Coordinates for the center of mass.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 1, 1))
| >>> mesh.center_of_mass()
| array([1., 1., 1.])
|
| points_to_double(self) -> 'Self'
| Convert the points datatype to double precision.
|
| Returns
| -------
| pyvista.PointSet
| Pointset with points in double precision.
|
| Notes
| -----
| This operates in place.
|
| Examples
| --------
| Create a mesh that has points of the type ``float32`` and
| convert the points to ``float64``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.points.dtype
| dtype('float32')
| >>> _ = mesh.points_to_double()
| >>> mesh.points.dtype
| dtype('float64')
|
| remove_cells(self, ind: 'VectorLike[bool] | VectorLike[int]', inplace: 'bool' = False) -> '_PointSet'
| Remove cells.
|
| Parameters
| ----------
| ind : VectorLike[int] | VectorLike[bool]
| Cell indices to be removed. The array can also be a
| boolean array of the same size as the number of cells.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| Returns
| -------
| pyvista.DataSet
| Same type as the input, but with the specified cells
| removed.
|
| See Also
| --------
| :ref:`ghost_cells_example`
|
| Examples
| --------
| Remove 20 cells from an unstructured grid.
|
| >>> from pyvista import examples
| >>> import pyvista as pv
| >>> hex_mesh = pv.read(examples.hexbeamfile)
| >>> removed = hex_mesh.remove_cells(range(10, 20))
| >>> removed.plot(color='lightblue', show_edges=True, line_width=3)
|
| shallow_copy(self, to_copy: 'DataSet') -> 'None'
| Create a shallow copy from a different dataset into this one.
|
| This method mutates this dataset and returns ``None``.
|
| Parameters
| ----------
| to_copy : pyvista.DataSet
| Data object to perform the shallow copy from.
|
| translate(self: 'Self', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False)
| Translate the mesh.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats of cartesian values to translate the mesh with.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed. This is
| only valid when not updating in place.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PointSet
| Translated pointset.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=True)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.poly_data.PolyDataFilters:
|
| __add__(self: 'PolyData', dataset)
| Merge these two meshes.
|
| __iadd__(self: 'PolyData', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``dataset`` is also a :class:`PolyData`.
| Otherwise we have to return a :class:`pyvista.UnstructuredGrid`,
| so the in-place merge attempt will raise.
|
| append_polydata(self, *meshes, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Append one or more PolyData into this one.
|
| Under the hood, the VTK :vtk:`vtkAppendPolyData`
| filter is used to perform the append operation.
|
| .. versionadded:: 0.40.0
|
| .. note::
| As stated in the VTK documentation of :vtk:`vtkAppendPolyData`,
| point and cell data are added to the output PolyData **only** if they
| are present across **all** input PolyData.
|
| .. seealso::
| :func:`pyvista.PolyDataFilters.merge`
|
| Parameters
| ----------
| *meshes : list[pyvista.PolyData]
| The PolyData(s) to append with the current one.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Appended PolyData(s).
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sp0 = pv.Sphere()
| >>> sp1 = sp0.translate((1, 0, 0))
| >>> appended = sp0.append_polydata(sp1)
| >>> appended.plot()
|
| Append more than one PolyData.
|
| >>> sp2 = sp0.translate((-1, 0, 0))
| >>> appended = sp0.append_polydata(sp1, sp2)
| >>> appended.plot()
|
| boolean_difference(self, other_mesh, tolerance=1e-05, progress_bar: 'bool' = False)
| Perform a boolean difference operation between two meshes.
|
| Essentially, boolean union, difference, and intersection are
| all the same operation. Just different parts of the objects
| are kept at the end.
|
| The difference of two manifold meshes ``A`` and ``B`` is the
| volume of the mesh in ``A`` not belonging to ``B``.
|
| .. note::
| If your boolean operations don't react the way you think they
| should (i.e. the wrong parts disappear), one of your meshes
| probably has its normals pointing inward. Use
| :func:`PolyDataFilters.plot_normals` to visualize the
| normals.
|
| .. note::
| Both meshes must be composed of all triangles. Check with
| :attr:`PolyData.is_all_triangles` and convert with
| :func:`PolyDataFilters.triangulate`.
|
| .. versionchanged:: 0.32.0
| Behavior changed to match default VTK behavior.
|
| Parameters
| ----------
| other_mesh : pyvista.PolyData
| Mesh operating on the source mesh.
|
| tolerance : float, default: 1e-5
| Tolerance used to determine when a point's absolute
| distance is considered to be zero.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The result of the boolean operation.
|
| Examples
| --------
| Demonstrate a boolean difference with two spheres. Note how
| the final mesh only includes ``sphere_a``.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> result = sphere_a - sphere_b
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere_a, color='r', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(sphere_b, color='b', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(result, color='lightblue')
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| boolean_intersection(self, other_mesh, tolerance=1e-05, progress_bar: 'bool' = False)
| Perform a boolean intersection operation on two meshes.
|
| Essentially, boolean union, difference, and intersection are
| all the same operation. Just different parts of the objects
| are kept at the end.
|
| The intersection of two manifold meshes ``A`` and ``B`` is the mesh
| which is the volume of ``A`` that is also in ``B``.
|
| .. note::
| If your boolean operations don't react the way you think they
| should (i.e. the wrong parts disappear), one of your meshes
| probably has its normals pointing inward. Use
| :func:`PolyDataFilters.plot_normals` to visualize the
| normals.
|
| .. note::
| This method returns the "volume" intersection between two
| meshes whereas the :func:`PolyDataFilters.intersection`
| filter returns the surface intersection between two meshes
| (which often resolves as a line).
|
|
| .. note::
| Both meshes must be composed of all triangles. Check with
| :attr:`PolyData.is_all_triangles` and convert with
| :func:`PolyDataFilters.triangulate`.
|
| .. versionadded:: 0.32.0
|
| .. versionchanged:: 0.45.0
| Define ``&`` operator to perform boolean intersection.
|
| Parameters
| ----------
| other_mesh : pyvista.PolyData
| Mesh operating on the source mesh.
|
| tolerance : float, default: 1e-5
| Tolerance used to determine when a point's absolute
| distance is considered to be zero.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The result of the boolean operation.
|
| Examples
| --------
| Demonstrate a boolean intersection with two spheres. Note how
| the final mesh only includes the intersection of the two.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> result = sphere_a & sphere_b
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere_a, color='r', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(sphere_b, color='b', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(result, color='lightblue')
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| boolean_union(self, other_mesh, tolerance=1e-05, progress_bar: 'bool' = False)
| Perform a boolean union operation on two meshes.
|
| Essentially, boolean union, difference, and intersection are
| all the same operation. Just different parts of the objects
| are kept at the end.
|
| The union of two manifold meshes ``A`` and ``B`` is the mesh
| which is in ``A``, in ``B``, or in both ``A`` and ``B``.
|
| .. note::
| If your boolean operations don't react the way you think they
| should (i.e. the wrong parts disappear), one of your meshes
| probably has its normals pointing inward. Use
| :func:`PolyDataFilters.plot_normals` to visualize the
| normals.
|
| .. note::
| The behavior of this filter varies from the
| :func:`PolyDataFilters.merge` filter. This filter attempts
| to create a manifold mesh and will not include internal
| surfaces when two meshes overlap.
|
| .. note::
| Both meshes must be composed of all triangles. Check with
| :attr:`PolyData.is_all_triangles` and convert with
| :func:`PolyDataFilters.triangulate`.
|
| .. versionchanged:: 0.32.0
| Behavior changed to match default VTK behavior.
|
| .. versionchanged:: 0.45.0
| Define ``|`` operator to perform boolean union.
|
| Parameters
| ----------
| other_mesh : pyvista.PolyData
| Mesh operating on the source mesh.
|
| tolerance : float, tolerance: 1e-5
| Tolerance used to determine when a point's absolute
| distance is considered to be zero.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The result of the boolean operation.
|
| Examples
| --------
| Demonstrate a boolean union with two spheres. Note how the
| final mesh includes both spheres.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> result = sphere_a | sphere_b
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere_a, color='r', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(sphere_b, color='b', style='wireframe', line_width=3)
| >>> _ = pl.add_mesh(result, color='lightblue')
| >>> pl.camera_position = 'xz'
| >>> pl.show()
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| clean(self, point_merging: 'bool' = True, tolerance=None, lines_to_points: 'bool' = True, polys_to_lines: 'bool' = True, strips_to_polys: 'bool' = True, inplace: 'bool' = False, absolute: 'bool' = True, progress_bar: 'bool' = False, **kwargs)
| Clean the mesh.
|
| This merges duplicate points, removes unused points, and/or
| removes degenerate cells.
|
| Parameters
| ----------
| point_merging : bool, optional
| Enables point merging. ``True`` by default.
|
| tolerance : float, optional
| Set merging tolerance. When enabled merging is set to
| absolute distance. If ``absolute`` is ``False``, then the
| merging tolerance is a fraction of the bounding box
| length. The alias ``merge_tol`` is also excepted.
|
| lines_to_points : bool, optional
| Enable or disable the conversion of degenerate lines to
| points. Enabled by default.
|
| polys_to_lines : bool, optional
| Enable or disable the conversion of degenerate polys to
| lines. Enabled by default.
|
| strips_to_polys : bool, optional
| Enable or disable the conversion of degenerate strips to
| polys.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| absolute : bool, optional
| Control if ``tolerance`` is an absolute distance or a
| fraction.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts for ``merge_tol`` to replace the ``tolerance``
| keyword argument. This may be deprecated in future.
|
| Returns
| -------
| pyvista.PolyData
| Cleaned mesh.
|
| See Also
| --------
| remove_unused_points
| Strictly remove unused points `without` merging points.
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Create a mesh with a degenerate face and then clean it,
| removing the degenerate face
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array([[0, 0, 0], [0, 1, 0], [1, 0, 0]], dtype=np.float32)
| >>> faces = np.array([3, 0, 1, 2, 3, 0, 2, 2])
| >>> mesh = pv.PolyData(points, faces)
| >>> mout = mesh.clean()
| >>> mout.faces # doctest:+SKIP
| array([3, 0, 1, 2])
|
| clip_closed_surface(self: 'PolyData', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, tolerance=1e-06, inplace: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a closed polydata surface with a plane.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| This currently only supports one plane but could be
| implemented to handle a plane collection.
|
| It will produce a new closed surface by creating new polygonal
| faces where the input data was clipped.
|
| Non-manifold surfaces should not be used as input for this
| filter. The input surface should have no open edges, and must
| not have any edges that are shared by more than two faces. In
| addition, the input surface should not self-intersect, meaning
| that the faces of the surface should only touch at their
| edges.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| tolerance : float, optional
| The tolerance for creating new points while clipping. If
| the tolerance is too small, then degenerate triangles
| might be produced.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| The clipped mesh.
|
| Examples
| --------
| Clip a sphere in the X direction centered at the origin. This
| will leave behind half a sphere in the positive X direction.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> clipped_mesh = sphere.clip_closed_surface('-z')
| >>> clipped_mesh.plot(show_edges=True, line_width=3)
|
| Clip the sphere at the XY plane and leave behind half the
| sphere in the positive Z direction. Shift the clip upwards to
| leave a smaller mesh behind.
|
| >>> clipped_mesh = sphere.clip_closed_surface('z', origin=[0, 0, 0.3])
| >>> clipped_mesh.plot(show_edges=True, line_width=3)
|
| See :ref:`clip_closed_surface_example` for more examples using this filter.
|
| collision(self, other_mesh, contact_mode=0, box_tolerance=0.001, cell_tolerance=0.0, n_cells_per_node=2, generate_scalars: 'bool' = False, progress_bar: 'bool' = False)
| Perform collision determination between two polyhedral surfaces.
|
| If ``collision_mode`` is set to all contacts, the output will
| be lines of contact. If ``collision_mode`` is first contact or half
| contacts then the Contacts output will be vertices.
|
| .. warning::
| Currently only triangles are processed. Use
| :func:`PolyDataFilters.triangulate` to convert any strips
| or polygons to triangles. Otherwise, the mesh will be
| converted for you within this method.
|
| Parameters
| ----------
| other_mesh : pyvista.DataSet
| Other mesh to test collision with. If the other mesh is
| not a surface, its external surface will be extracted and
| triangulated.
|
| contact_mode : int, default: 0
| Contact mode. One of the following:
|
| * 0 - All contacts. Find all the contacting cell pairs
| with two points per collision
| * 1 - First contact. Quickly find the first contact point.
| * 2 - Half contacts. Find all the contacting cell pairs
| with one point per collision.
|
| box_tolerance : float, default: 0.001
| Oriented bounding box (OBB) tree tolerance in world coordinates.
|
| cell_tolerance : float, default: 0.0
| Cell tolerance (squared value).
|
| n_cells_per_node : int, default: 2
| Number of cells in each OBB.
|
| generate_scalars : bool, default: False
| Flag to visualize the contact cells. If ``True``, the
| contacting cells will be colored from red through blue,
| with collisions first determined colored red. This array
| is stored as ``"collision_rgba"``.
|
| .. note::
| This will remove any other cell arrays in the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing collisions in the ``field_data``
| attribute named ``"ContactCells"``. Array only exists
| when there are collisions.
|
| int
| Number of collisions.
|
| Notes
| -----
| Due to the nature of the :vtk:`vtkCollisionDetectionFilter`,
| repeated uses of this method will be slower that using the
| :vtk:`vtkCollisionDetectionFilter` directly. The first
| update of the filter creates two instances of :vtk:`vtkOBBTree`,
| which can be subsequently updated by modifying the transform or
| matrix of the input meshes.
|
| This method assumes no transform and is easier to use for
| single collision tests, but it is recommended to use a
| combination of ``pyvista`` and ``vtk`` for rapidly computing
| repeated collisions. See the `Collision Detection Example
| <https://kitware.github.io/vtk-examples/site/Python/Visualization/CollisionDetection/>`_
|
| Examples
| --------
| Compute the collision between a sphere and the back faces of a
| cube and output the cell indices of the first 10 collisions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere(radius=0.5)
| >>> mesh_b = pv.Cube(center=(0.5, 0.5, 0.5)).extract_cells([0, 2, 4])
| >>> collision, ncol = mesh_a.collision(mesh_b, cell_tolerance=1)
| >>> collision['ContactCells'][:10]
| pyvista_ndarray([464, 0, 0, 29, 29, 27, 27, 28, 28, 23])
|
| Plot the collisions by creating a collision mask with the
| ``"ContactCells"`` field data. Cells with a collision are
| colored red.
|
| >>> scalars = np.zeros(collision.n_cells, dtype=bool)
| >>> scalars[collision.field_data['ContactCells']] = True
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... collision,
| ... scalars=scalars,
| ... show_scalar_bar=False,
| ... cmap='bwr',
| ... )
| >>> _ = pl.add_mesh(
| ... mesh_b,
| ... color='lightblue',
| ... line_width=5,
| ... opacity=0.7,
| ... show_edges=True,
| ... )
| >>> pl.show()
|
| Alternatively, simply plot the collisions using the default
| ``'collision_rgba'`` array after enabling ``generate_scalars``.
|
| >>> collision, ncol = mesh_a.collision(
| ... mesh_b, cell_tolerance=1, generate_scalars=True
| ... )
| >>> collision.plot()
|
| See :ref:`collision_example` for more examples using this filter.
|
| compute_arc_length(self, progress_bar: 'bool' = False)
| Compute the arc length over the length of the probed line.
|
| It adds a new point-data array named ``"arc_length"`` with the
| computed arc length for each of the polylines in the
| input. For all other cell types, the arc length is set to 0.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| float
| Arc length of the length of the probed line.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> path = sphere.geodesic(0, 100)
| >>> length = path.compute_arc_length()['arc_length'][-1]
| >>> f'Length is {length:.3f}'
| 'Length is 0.812'
|
| This is identical to the geodesic_distance.
|
| >>> length = sphere.geodesic_distance(0, 100)
| >>> f'Length is {length:.3f}'
| 'Length is 0.812'
|
| You can also plot the arc_length.
|
| >>> arc = path.compute_arc_length()
| >>> arc.plot(scalars='arc_length')
|
| compute_normals(self, cell_normals: 'bool' = True, point_normals: 'bool' = True, split_vertices: 'bool' = False, flip_normals: 'bool' = False, consistent_normals: 'bool' = True, auto_orient_normals: 'bool' = False, non_manifold_traversal: 'bool' = True, feature_angle=30.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Compute point and/or cell normals for a mesh.
|
| The filter can reorder polygons to insure consistent
| orientation across polygon neighbors. Sharp edges can be split
| and points duplicated with separate normals to give crisp
| (rendered) surface definition. It is also possible to globally
| flip the normal orientation.
|
| The algorithm works by determining normals for each polygon
| and then averaging them at shared points. When sharp edges are
| present, the edges are split and new points generated to
| prevent blurry edges (due to Phong shading).
|
| An array named ``"Normals"`` is stored with the mesh.
|
| .. warning::
|
| - Normals can only be computed for polygons and triangle strips.
| Point clouds are not supported.
| - Triangle strips are broken up into triangle polygons.
| You may want to restrip the triangles.
| - Previous arrays named ``"Normals"`` will be overwritten.
|
| Parameters
| ----------
| cell_normals : bool, default: True
| Calculation of cell normals.
|
| point_normals : bool, default: True
| Calculation of point normals.
|
| split_vertices : bool, default: False
| Splitting of sharp edges. Indices to the original points are
| tracked in the ``"pyvistaOriginalPointIds"`` array.
|
| flip_normals : bool, default: False
| Set global flipping of normal orientation. Flipping
| modifies both the normal direction and the order of a
| cell's points.
|
| consistent_normals : bool, default: True
| Enforcement of consistent polygon ordering.
|
| auto_orient_normals : bool, default: False
| Turn on/off the automatic determination of correct normal
| orientation. NOTE: This assumes a completely closed
| surface (i.e. no boundary edges) and no non-manifold
| edges. If these constraints do not hold, all bets are
| off. This option adds some computational complexity, and
| is useful if you do not want to have to inspect the
| rendered image to determine whether to turn on the
| ``flip_normals`` flag. However, this flag can work with
| the ``flip_normals`` flag, and if both are set, all the
| normals in the output will point "inward".
|
| non_manifold_traversal : bool, default: True
| Turn on/off traversal across non-manifold edges. Changing
| this may prevent problems where the consistency of
| polygonal ordering is corrupted due to topological
| loops.
|
| feature_angle : float, default: 30.0
| The angle that defines a sharp edge. If the difference in
| angle across neighboring polygons is greater than this
| value, the shared edge is considered "sharp".
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Raises
| ------
| TypeError
| If the mesh contains only ``LINE`` or ``VERTEX`` cell types.
| Normals cannot be computed for these cells.
|
| Returns
| -------
| pyvista.PolyData
| Updated mesh with cell and point normals.
|
| See Also
| --------
| pyvista.PolyData.point_normals
| Returns the array of point normals.
| pyvista.PolyData.cell_normals
| Returns the array of cell normals.
| pyvista.PolyDataFilters.flip_normal_vectors
| Flip cell and point normals.
| pyvista.PolyDataFilters.flip_faces
| Flip the orientation of the faces.
|
| Examples
| --------
| Compute the point normals of the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere = sphere.compute_normals(cell_normals=False)
| >>> normals = sphere['Normals']
| >>> normals.shape
| (842, 3)
|
| Alternatively, create a new mesh when computing the normals
| and compute both cell and point normals.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_with_norm = sphere.compute_normals()
| >>> sphere_with_norm.point_data['Normals'].shape
| (842, 3)
| >>> sphere_with_norm.cell_data['Normals'].shape
| (1680, 3)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| contour_banded(self: 'PolyData', n_contours, rng=None, scalars=None, component=0, clip_tolerance=1e-06, generate_contour_edges: 'bool' = True, scalar_mode='value', clipping: 'bool' = True, progress_bar: 'bool' = False)
| Generate filled contours.
|
| Generates filled contours for :vtk:`vtkPolyData`. Filled contours are
| bands of cells that all have the same cell scalar value, and can
| therefore be colored the same. The method is also referred to as
| filled contour generation.
|
| This filter implements :vtk:`vtkBandedPolyDataContourFilter`.
|
| Parameters
| ----------
| n_contours : int
| Number of contours.
|
| rng : Sequence, optional
| Range of the scalars. Optional and defaults to the minimum and
| maximum of the active scalars of ``scalars``.
|
| scalars : str, optional
| The name of the scalar array to use for contouring. If ``None``,
| the active scalar array will be used.
|
| component : int, default: 0
| The component to use of an input scalars array with more than one
| component.
|
| clip_tolerance : float, default: 1e-6
| Set/Get the clip tolerance. Warning: setting this too large will
| certainly cause numerical issues. Change from the default value at
| your own risk. The actual internal clip tolerance is computed by
| multiplying ``clip_tolerance`` by the scalar range.
|
| generate_contour_edges : bool, default: True
| Controls whether contour edges are generated. Contour edges are
| the edges between bands. If enabled, they are generated from
| polygons/triangle strips and returned as a second output.
|
| scalar_mode : str, default: 'value'
| Control whether the cell scalars are output as an integer index or
| a scalar value. If ``'index'``, the index refers to the bands
| produced by the clipping range. If ``'value'``, then a scalar value
| which is a value between clip values is used.
|
| clipping : bool, default: True
| Indicate whether to clip outside ``rng`` and only return cells with
| values within ``rng``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData
| Surface containing the contour surface.
|
| edges : pyvista.PolyData
| Optional edges when ``generate_contour_edges`` is ``True``.
|
| Examples
| --------
| Plot the random hills dataset and with 8 contour lines. Note how we use 7
| colors here (``n_contours - 1``).
|
| >>> import pyvista as pv
| >>> from pyvista import examples
|
| >>> mesh = examples.load_random_hills()
| >>> n_contours = 8
| >>> _, edges = mesh.contour_banded(n_contours)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... edges,
| ... line_width=5,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(mesh, n_colors=n_contours - 1, cmap='Set3')
| >>> pl.show()
|
| Extract the surface from the uniform grid dataset and plot its contours
| alongside the output from the banded contour filter.
|
| >>> surf = examples.load_uniform().extract_surface(algorithm=None)
| >>> n_contours = 5
| >>> rng = [200, 500]
| >>> output, edges = surf.contour_banded(n_contours, rng=rng)
|
| >>> dargs = dict(n_colors=n_contours - 1, clim=rng)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... edges,
| ... line_width=5,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(surf, opacity=0.3, **dargs)
| >>> _ = pl.add_mesh(output, **dargs)
| >>> pl.show()
|
| curvature(self, curv_type='mean', progress_bar: 'bool' = False)
| Return the pointwise curvature of a mesh.
|
| See :ref:`connectivity_example` for more examples using this
| filter.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| Curvature type. One of the following:
|
| * ``"mean"``
| * ``"gaussian"``
| * ``"maximum"``
| * ``"minimum"``
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Array of curvature values.
|
| Examples
| --------
| Calculate the mean curvature of the hills example mesh and plot it.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> curv = hills.curvature()
| >>> hills.plot(scalars=curv)
|
| Show the curvature array.
|
| >>> curv # doctest:+SKIP
| array([0.20587616, 0.06747695, ..., 0.11781171, 0.15988467])
|
| decimate(self, target_reduction, volume_preservation: 'bool' = False, attribute_error: 'bool | None' = None, scalars: 'bool | None' = None, vectors: 'bool | None' = None, normals: 'bool | None' = None, tcoords: 'bool | None' = None, tensors: 'bool | None' = None, scalars_weight=0.1, vectors_weight=0.1, normals_weight=0.1, tcoords_weight=0.1, tensors_weight=0.1, inplace: 'bool' = False, progress_bar: 'bool' = False, boundary_constraints: 'bool' = False, boundary_weight: 'float' = 1.0, enable_all_attribute_error: 'bool' = False)
| Reduce the number of triangles in a triangular mesh using :vtk:`vtkQuadricDecimation`.
|
| .. versionchanged:: 0.45
| ``scalars``, ``vectors``, ``normals``, ``tcoords`` and ``tensors`` are now disabled by
| default. They can be enabled all together using ``enable_all_attribute_error``.
|
|
| Parameters
| ----------
| target_reduction : float
| Fraction of the original mesh to remove.
| If ``target_reduction`` is set to 0.9, this filter will try
| to reduce the data set to 10% of its original size and will
| remove 90% of the input triangles.
|
| volume_preservation : bool, default: False
| Decide whether to activate volume preservation which greatly
| reduces errors in triangle normal direction. If ``False``,
| volume preservation is disabled and if ``attribute_error``
| is active, these errors can be large.
|
| attribute_error : bool, default: False
| Decide whether to include data attributes in the error metric. If
| ``False``, then only geometric error is used to control the
| decimation. If ``True``, the following flags are used to specify
| which attributes are to be included in the error calculation.
|
| .. deprecated:: 0.45.0
|
| scalars : bool, default: False
| This flags control specifically if the **scalar** attributes
| are to be included in the error calculation.
|
| vectors : bool, default: False
| See ``scalars`` parameter.
|
| normals : bool, default: False
| See ``scalars`` parameter.
| .. versionchanged:: 0.45.0
|
| tcoords : bool, default: False
| See ``scalars`` parameter.
|
| tensors : bool, default: False
| See ``scalars`` parameter.
|
| scalars_weight : float, default: 0.1
| The scaling weight contribution of the scalar attribute.
| These values are used to weight the contribution of the
| attributes towards the error metric.
|
| vectors_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| normals_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| tcoords_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| tensors_weight : float, default: 0.1
| See ``scalars_weight`` parameter.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| boundary_constraints: bool, default: False
| Use the legacy weighting by boundary_edge_length instead of by
| boundary_edge_length^2 for backwards compatibility.
| It requires vtk>=9.3.0.
|
| .. versionadded:: 0.45.0
|
| boundary_weight: float, default: 1.0
| A floating point factor to weigh the boundary quadric constraints
| by: higher factors further constrain the boundary.
| It requires vtk>=9.3.0.
|
| .. versionadded:: 0.45.0
|
| enable_all_attribute_error: bool, default: False
| This flag control the default value of all attribute metrics to
| eventually include them in the error calculation
|
| .. versionadded:: 0.45.0
|
| Returns
| -------
| pyvista.PolyData
| Decimated mesh.
|
| See Also
| --------
| decimate_pro
| Another option for triangular meshes.
| decimate_polyline
| For use with polylines.
|
| Notes
| -----
| If you encounter a segmentation fault or other error, consider using
| :func:`pyvista.PolyDataFilters.clean` to remove any invalid cells
| before using this filter.
|
| Examples
| --------
| Decimate a sphere. First plot the sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=60, theta_resolution=60)
| >>> sphere.plot(show_edges=True, line_width=2)
|
| Now decimate it by 75% and plot it.
|
| >>> decimated = sphere.decimate(0.75)
| >>> decimated.plot(show_edges=True, line_width=2)
|
| Decimate taking scalars attributes into account:
|
| >>> decimated = sphere.decimate(0.5, scalars=True)
|
| Decimate taking all attributes **except** normals into account:
|
| >>> decimated = sphere.decimate(
| ... 0.5, enable_all_attribute_error=True, normals=False
| ... )
|
| See :ref:`decimate_example` for more examples using this filter.
|
| decimate_polyline(self, reduction: 'float', *, maximum_error: 'float' = 10.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Reduce the number of lines in a polyline mesh.
|
| This filter uses :vtk:`vtkDecimatePolylineFilter`.
|
| .. versionadded:: 0.45.0
|
| Parameters
| ----------
| reduction : float
| Reduction factor. A value of 0.9 will leave 10% of the
| original number of vertices.
|
| maximum_error : float, default: 10.
| Fraction of the maximum length of the input data bounding box
| to limit reduction. This might prevent the full reduction from
| being achieved. Default of ``10.`` should not limit reduction.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated mesh.
|
| Warnings
| --------
| From :vtk:`vtkDecimatePolylineFilter` documentation: this algorithm is a very
| simple implementation that overlooks some potential complexities.
| For example, if a vertex is multiply connected, meaning that it is
| used by multiple distinct polylines, then the extra topological
| constraints are ignored. This can produce less than optimal results.
|
| See Also
| --------
| decimate
| For use with triangular meshes.
| decimate_pro
| Another option for triangular meshes.
|
| Examples
| --------
| Generate a circle, builtin function returns a Polygon cell.
|
| >>> import pyvista as pv
| >>> circle = pv.Circle(resolution=30)
|
| Convert to a Polyline. A polyline requires duplicating reference
| to initial point to close the circle.
|
| >>> circle_polyline = pv.PolyData(
| ... circle.points, lines=[31] + list(range(30)) + [0]
| ... )
| >>> circle_polyline.n_points
| 30
|
| Decimate ~50% of points.
|
| >>> decimate_some = circle_polyline.decimate_polyline(0.5)
| >>> decimate_some.n_points
| 14
|
| Decimate more points.
|
| >>> decimate_more = circle_polyline.decimate_polyline(0.75)
| >>> decimate_more.n_points
| 6
|
| Compare decimated polylines.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(circle_polyline, label='Circle', color='red', line_width=5)
| >>> _ = pl.add_mesh(
| ... decimate_some,
| ... label='Decimated some',
| ... color='blue',
| ... line_width=5,
| ... )
| >>> _ = pl.add_mesh(
| ... decimate_more,
| ... label='Decimated more',
| ... color='black',
| ... line_width=5,
| ... )
| >>> pl.view_xy()
| >>> _ = pl.add_legend(face='line', size=(0.25, 0.25))
| >>> pl.show()
|
| See :ref:`decimate_example` for more examples using this filter.
|
| decimate_pro(self, reduction, feature_angle=45.0, split_angle=75.0, splitting: 'bool' = True, pre_split_mesh: 'bool' = False, preserve_topology: 'bool' = False, boundary_vertex_deletion: 'bool' = True, max_degree=None, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Reduce the number of triangles in a triangular mesh.
|
| It forms a good approximation to the original geometry. Based
| on the algorithm originally described in "Decimation of
| Triangle Meshes", Proc Siggraph 92
| (https://doi.org/10.1145/133994.134010).
|
| Parameters
| ----------
| reduction : float
| Reduction factor. A value of 0.9 will leave 10% of the
| original number of vertices.
|
| feature_angle : float, default: 45.0
| Angle used to define what an edge is (i.e., if the surface
| normal between two adjacent triangles is >= ``feature_angle``,
| an edge exists).
|
| split_angle : float, default: 75.0
| Angle used to control the splitting of the mesh. A split
| line exists when the surface normals between two edge
| connected triangles are >= ``split_angle``.
|
| splitting : bool, default: True
| Controls the splitting of the mesh at corners, along
| edges, at non-manifold points, or anywhere else a split is
| required. Turning splitting off will better preserve the
| original topology of the mesh, but may not necessarily
| give the exact requested decimation.
|
| pre_split_mesh : bool, default: False
| Separates the mesh into semi-planar patches, which are
| disconnected from each other. This can give superior
| results in some cases. If ``pre_split_mesh`` is set to
| ``True``, the mesh is split with the specified
| ``split_angle``. Otherwise mesh splitting is deferred as
| long as possible.
|
| preserve_topology : bool, default: False
| Controls topology preservation. If on, mesh splitting and
| hole elimination will not occur. This may limit the
| maximum reduction that may be achieved.
|
| boundary_vertex_deletion : bool, default: True
| Allow deletion of vertices on the boundary of the mesh.
| Turning this off may limit the maximum reduction that may
| be achieved.
|
| max_degree : float, optional
| The maximum vertex degree. If the number of triangles
| connected to a vertex exceeds ``max_degree``, then the
| vertex will be split. The complexity of the triangulation
| algorithm is proportional to ``max_degree**2``. Setting ``max_degree``
| small can improve the performance of the algorithm.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated mesh.
|
| See Also
| --------
| decimate
| Another option for triangular meshes.
| decimate_polyline
| For use with polylines.
|
| Examples
| --------
| Decimate a sphere. First plot the sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=60, theta_resolution=60)
| >>> sphere.plot(show_edges=True, line_width=2)
|
| Now decimate it and plot it.
|
| >>> decimated = sphere.decimate_pro(0.75)
| >>> decimated.plot(show_edges=True, line_width=2)
|
| See :ref:`decimate_example` for more examples using this filter.
|
| delaunay_2d(self, tol=1e-05, alpha=0.0, offset=1.0, bound: 'bool' = False, inplace: 'bool' = False, edge_source=None, progress_bar: 'bool' = False)
| Apply a 2D Delaunay filter along the best fitting plane.
|
| This filter can be used to generate a 2d surface from a set of
| points on a plane. If you want to create a surface from a
| point cloud, see :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| tol : float, default: 1e-05
| Specify a tolerance to control discarding of closely
| spaced points. This tolerance is specified as a fraction
| of the diagonal length of the bounding box of the points.
|
| alpha : float, default: 0.0
| Specify alpha (or distance) value to control output of
| this filter. For a non-zero alpha value, only edges or
| triangles contained within a sphere centered at mesh
| vertices will be output. Otherwise, only triangles will be
| output.
|
| offset : float, default: 1.0
| Specify a multiplier to control the size of the initial,
| bounding Delaunay triangulation.
|
| bound : bool, default: False
| Boolean controls whether bounding triangulation points
| and associated triangles are included in the
| output. These are introduced as an initial triangulation
| to begin the triangulation process. This feature is nice
| for debugging output.
|
| inplace : bool, default: False
| If ``True``, overwrite this mesh with the triangulated
| mesh.
|
| edge_source : pyvista.PolyData, optional
| Specify the source object used to specify constrained
| edges and loops. If set, and lines/polygons are defined, a
| constrained triangulation is created. The lines/polygons
| are assumed to reference points in the input point set
| (i.e. point ids are identical in the input and
| source).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh from the 2D delaunay filter.
|
| Examples
| --------
| First, generate 30 points on circle and plot them.
|
| >>> import pyvista as pv
| >>> points = pv.Polygon(n_sides=30).points
| >>> circle = pv.PolyData(points)
| >>> circle.plot(show_edges=True, point_size=15)
|
| Use :func:`delaunay_2d` to fill the interior of the circle.
|
| >>> filled_circle = circle.delaunay_2d()
| >>> filled_circle.plot(show_edges=True, line_width=5)
|
| Use the ``edge_source`` parameter to create a constrained delaunay
| triangulation and plot it.
|
| >>> squar = pv.Polygon(n_sides=4, radius=8, fill=False)
| >>> squar = squar.rotate_z(45, inplace=False)
| >>> circ0 = pv.Polygon(center=(2, 3, 0), n_sides=30, radius=1)
| >>> circ1 = pv.Polygon(center=(-2, -3, 0), n_sides=30, radius=1)
| >>> comb = circ0.append_polydata(circ1, squar)
| >>> tess = comb.delaunay_2d(edge_source=comb)
| >>> tess.plot(cpos='xy', show_edges=True)
|
| See :ref:`create_tri_surface_example` for more examples using this filter.
|
| edge_mask(self, angle, progress_bar: 'bool' = False)
| Return a mask of the points of a surface mesh with a surface angle greater than angle.
|
| Parameters
| ----------
| angle : float
| Angle to consider an edge.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Mask of points with an angle greater than ``angle``.
|
| Examples
| --------
| Plot the mask of points that exceed 45 degrees.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube().triangulate().subdivide(4)
| >>> mask = mesh.edge_mask(45)
| >>> mesh.plot(scalars=mask)
|
| Show the array of masked points.
|
| >>> mask # doctest:+SKIP
| array([ True, True, True, ..., False, False, False])
|
| extrude(self, vector, capping=None, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Sweep polygonal data creating a "skirt" from free edges.
|
| This will create a line from vertices.
|
| This takes polygonal data as input and generates polygonal
| data on output. The input dataset is swept according to some
| extrusion function and creates new polygonal primitives. These
| primitives form a "skirt" or swept surface. For example,
| sweeping a line results in a quadrilateral, and sweeping a
| triangle creates a "wedge".
|
| The skirt is generated by locating certain topological
| features. Free edges (edges of polygons or triangle strips
| only used by one polygon or triangle strips) generate
| surfaces. This is true also of lines or polylines. Vertices
| generate lines.
|
| .. versionchanged:: 0.32.0
| The ``capping`` keyword was added with a default of ``False``.
| The previously used VTK default corresponds to ``capping=True``.
| In a future version the default will be changed to ``True`` to
| match the behavior of the underlying VTK filter.
|
| Parameters
| ----------
| vector : numpy.ndarray or sequence
| Direction and length to extrude the mesh in.
|
| capping : bool, optional
| Control if the sweep of a 2D object is capped. The default is
| ``False``, which differs from VTK's default.
|
| .. warning::
| The ``capping`` keyword was added in version 0.32.0 with a
| default value of ``False``. In a future version this default
| will be changed to ``True`` to match the behavior of the
| underlying VTK filter. It is recommended to explicitly pass
| a value for this keyword argument to prevent future changes
| in behavior and warnings.
|
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extruded mesh.
|
| Examples
| --------
| Extrude a half circle arc.
|
| >>> import pyvista as pv
| >>> arc = pv.CircularArc(pointa=[-1, 0, 0], pointb=[1, 0, 0], center=[0, 0, 0])
| >>> mesh = arc.extrude([0, 0, 1], capping=False)
| >>> mesh.plot(color='lightblue')
|
| Extrude and cap an 8 sided polygon.
|
| >>> poly = pv.Polygon(n_sides=8)
| >>> mesh = poly.extrude((0, 0, 1.5), capping=True)
| >>> mesh.plot(line_width=5, show_edges=True)
|
| extrude_rotate(self, resolution=30, inplace: 'bool' = False, translation=0.0, dradius=0.0, angle=360.0, capping=None, rotation_axis=(0, 0, 1), progress_bar: 'bool' = False)
| Sweep polygonal data creating "skirt" from free edges/lines, and lines from vertices.
|
| This takes polygonal data as input and generates polygonal
| data on output. The input dataset is swept around the axis
| to create new polygonal primitives. These primitives form a
| "skirt" or swept surface. For example, sweeping a line results
| in a cylindrical shell, and sweeping a circle creates a torus.
|
| There are a number of control parameters for this filter. You
| can control whether the sweep of a 2D object (i.e., polygon or
| triangle strip) is capped with the generating geometry via the
| ``capping`` parameter. Also, you can control the angle of
| rotation, and whether translation along the axis is
| performed along with the rotation. (Translation is useful for
| creating "springs".) You also can adjust the radius of the
| generating geometry with the ``dradius`` parameter.
|
| The skirt is generated by locating certain topological
| features. Free edges (edges of polygons or triangle strips
| only used by one polygon or triangle strips) generate
| surfaces. This is true also of lines or polylines. Vertices
| generate lines.
|
| This filter can be used to model axisymmetric objects like
| cylinders, bottles, and wine glasses; or translational
| rotational symmetric objects like springs or corkscrews.
|
| .. versionchanged:: 0.32.0
| The ``capping`` keyword was added with a default of ``False``.
| The previously used VTK default corresponds to ``capping=True``.
| In a future version the default will be changed to ``True`` to
| match the behavior of the underlying VTK filter.
|
| Parameters
| ----------
| resolution : int, optional
| Number of pieces to divide line into.
|
| inplace : bool, default: False
| Overwrites the original mesh inplace.
|
| translation : float, optional
| Total amount of translation along the axis.
|
| dradius : float, optional
| Change in radius during sweep process.
|
| angle : float, optional
| The angle of rotation in degrees.
|
| capping : bool, optional
| Control if the sweep of a 2D object is capped. The default is
| ``False``, which differs from VTK's default.
|
| .. warning::
| The ``capping`` keyword was added in version 0.32.0 with a
| default value of ``False``. In a future version this default
| will be changed to ``True`` to match the behavior of the
| underlying VTK filter. It is recommended to explicitly pass
| a value for this keyword argument to prevent future changes
| in behavior and warnings.
|
| rotation_axis : numpy.ndarray or sequence, optional
| The direction vector of the axis around which the rotation is done.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Rotationally extruded mesh.
|
| See Also
| --------
| :ref:`extrude_rotate_example`
|
| Examples
| --------
| Create a "spring" using the rotational extrusion filter.
|
| >>> import pyvista as pv
| >>> profile = pv.Polygon(
| ... center=[1.25, 0.0, 0.0],
| ... radius=0.2,
| ... normal=(0, 1, 0),
| ... n_sides=30,
| ... )
| >>> extruded = profile.extrude_rotate(
| ... resolution=360,
| ... translation=4.0,
| ... dradius=0.5,
| ... angle=1500.0,
| ... capping=True,
| ... )
| >>> extruded.plot(smooth_shading=True)
|
| Create a "wine glass" using the rotational extrusion filter.
|
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [-0.18, 0, 0],
| ... [-0.18, 0, 0.01],
| ... [-0.18, 0, 0.02],
| ... [-0.01, 0, 0.03],
| ... [-0.01, 0, 0.04],
| ... [-0.02, 0, 0.5],
| ... [-0.05, 0, 0.75],
| ... [-0.1, 0, 0.8],
| ... [-0.2, 0, 1.0],
| ... ]
| ... )
| >>> spline = pv.Spline(points, 30)
| >>> extruded = spline.extrude_rotate(resolution=20, capping=False)
| >>> extruded.plot(color='lightblue')
|
| extrude_trim(self, direction, trim_surface, extrusion='boundary_edges', capping='intersection', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extrude polygonal data trimmed by a surface.
|
| The input dataset is swept along a specified direction forming a
| "skirt" from the boundary edges 2D primitives (i.e., edges used
| by only one polygon); and/or from vertices and lines. The extent
| of the sweeping is defined where the sweep intersects a
| user-specified surface.
|
| Parameters
| ----------
| direction : numpy.ndarray or sequence
| Direction vector to extrude.
|
| trim_surface : pyvista.PolyData
| Surface which trims the surface.
|
| extrusion : str, default: "boundary_edges"
| Control the strategy of extrusion. One of the following:
|
| * ``"boundary_edges"``
| * ``"all_edges"``
|
| The default only generates faces on the boundary of the original
| input surface. When using ``"all_edges"``, faces are created along
| interior points as well.
|
| capping : str, default: "intersection"
| Control the strategy of capping. One of the following:
|
| * ``"intersection"``
| * ``"minimum_distance"``
| * ``"maximum_distance"``
| * ``"average_distance"``
|
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extruded mesh trimmed by a surface.
|
| See Also
| --------
| :ref:`extrude_trim_example`
|
| Examples
| --------
| Extrude a disc.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> plane = pv.Plane(i_size=2, j_size=2, direction=[0, 0.8, 1])
| >>> disc = pv.Disc(center=(0, 0, -1), c_res=50)
| >>> direction = [0, 0, 1]
| >>> extruded_disc = disc.extrude_trim(direction, plane)
| >>> extruded_disc.plot(smooth_shading=True, split_sharp_edges=True)
|
| fill_holes(self, hole_size, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Fill holes in a :class:`pyvista.PolyData` or :vtk:`vtkPolyData` object.
|
| Holes are identified by locating boundary edges, linking them
| together into loops, and then triangulating the resulting
| loops. Note that you can specify an approximate limit to the
| size of the hole that can be filled.
|
| .. warning::
| This method is known to segfault. Use at your own risk.
|
| Parameters
| ----------
| hole_size : float
| Specifies the maximum hole size to fill. This is
| represented as a radius to the bounding circumsphere
| containing the hole. Note that this is an approximate
| area; the actual area cannot be computed without first
| triangulating the hole.
|
| inplace : bool, default: False
| Return new mesh or overwrite input.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh with holes filled if ``inplace=False``.
|
| Examples
| --------
| Create a partial sphere with a hole and then fill it.
|
| >>> import pyvista as pv
| >>> sphere_with_hole = pv.Sphere(end_theta=330)
| >>> sphere = sphere_with_hole.fill_holes(1000) # doctest:+SKIP
| >>> edges = sphere.extract_feature_edges(
| ... feature_edges=False, manifold_edges=False
| ... ) # doctest:+SKIP
| >>> assert edges.n_cells == 0 # doctest:+SKIP
|
| See :ref:`fill_holes_example` for more examples using this filter.
|
| flip_faces(self: 'PolyData', *, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Flip the orientation of the faces.
|
| The flip is performed by reversing the order of indices in the cell
| connectivity list. In other libraries, this operation is sometimes
| referred to as "flip orientation", "reverse cells", "reverse face
| orientations", or similar.
|
| .. note::
|
| Polygon cells have an implicitly-defined orientation, and reversing
| the ordering affects how normals are computed by filters like
| :meth:`~pyvista.PolyDataFilters.compute_normals`.
|
| .. note::
| This filter does not modify any existing normals which may be present
| in the dataset. Use :meth:`~pyvista.PolyDataFilters.flip_normal_vectors`
| to flip the normal vectors.
|
| .. warning::
|
| This filter does not produce the correct output for
| :attr:`~pyvista.CellType.TRIANGLE_STRIP` cells,
| see https://gitlab.kitware.com/vtk/vtk/-/issues/18634.
| Use :meth:`~pyvista.PolyDataFilters.triangulate` to triangulate the mesh
| first.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh with flipped faces.
|
| See Also
| --------
| pyvista.PolyDataFilters.flip_normal_vectors
| Flip the direction of the point and cell normals.
| pyvista.PolyDataFilters.compute_normals
| Compute new normals. Includes the option to flip the normals.
| pyvista.PolyData.point_normals
| Returns the array of point normals.
| pyvista.PolyData.cell_normals
| Returns the array of cell normals.
|
| Examples
| --------
| Flip the faces of a sphere. Show the point ids of the first cell
| before and after the flip.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.regular_faces[0]
| array([ 2, 30, 0])
|
| >>> sphere_flipped = sphere.flip_faces()
| >>> sphere_flipped.regular_faces[0]
| array([ 0, 30, 2])
|
| Note that the sphere also has pre-computed normals which have not been
| affected by this filter.
|
| >>> sphere.point_data['Normals'][0]
| pyvista_ndarray([0., 0., 1.], dtype=float32)
|
| >>> sphere_flipped.point_data['Normals'][0]
| pyvista_ndarray([0., 0., 1.], dtype=float32)
|
| See :ref:`boolean_operations_example` for more examples using this filter.
|
| flip_normal_vectors(self: 'PolyData', *, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Flip the direction of the mesh's point and cell normal vectors.
|
| This filter effectively multiplies the point and cell normals by ``-1``.
| It has no effect if no active normals are currently set.
|
| .. note::
|
| Polygon cells have an implicitly-defined orientation which may differ
| from the orientation of the normal vectors. To ensure that the normals
| are consistent with this implicit definition, consider also using
| :meth:`~pyvista.PolyDataFilters.flip_faces` or re-computing normals with
| :meth:`~pyvista.PolyDataFilters.compute_normals` and enabling the
| `flip_normals` option.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| inplace : bool, default: False
| Overwrites the original mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh with point and cell normal directions flipped.
|
| See Also
| --------
| pyvista.PolyDataFilters.flip_faces
| Flip the orientation of the faces.
| pyvista.PolyDataFilters.compute_normals
| Compute new normals. Includes the option to flip the normals.
| pyvista.PolyData.point_normals
| Returns the array of point normals.
| pyvista.PolyData.cell_normals
| Returns the array of cell normals.
|
| Examples
| --------
| Flip the normal vectors of a sphere. Show one of the normal vectors
| before and after the flip.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.point_data['Normals'][0]
| pyvista_ndarray([0., 0., 1.], dtype=float32)
|
| >>> sphere_flipped = sphere.flip_normal_vectors()
| >>> sphere_flipped.point_data['Normals'][0]
| pyvista_ndarray([-0., -0., -1.], dtype=float32)
|
| Note that the sphere's cell ordering has not been affected by this filter.
|
| >>> sphere.regular_faces[0]
| array([ 2, 30, 0])
|
| >>> sphere_flipped.regular_faces[0]
| array([ 2, 30, 0])
|
| flip_normals(self)
| Flip normals of a triangular mesh by reversing the point ordering.
|
| .. deprecated:: 0.45
|
| This filter is deprecated. Use ``flip_faces(inplace=True)`` instead.
|
| Examples
| --------
| Flip the normals of a sphere and plot the normals before and
| after the flip.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere.plot_normals(mag=0.1)
| >>> sphere.flip_normals() # doctest:+SKIP
| >>> sphere.plot_normals(mag=0.1, opacity=0.5)
|
| geodesic(self, start_vertex, end_vertex, inplace: 'bool' = False, keep_order: 'bool' = True, use_scalar_weights: 'bool' = False, progress_bar: 'bool' = False)
| Calculate the geodesic path between two vertices using Dijkstra's algorithm.
|
| This will add an array titled ``'vtkOriginalPointIds'`` of the input
| mesh's point ids to the output mesh. The default behavior of the
| underlying :vtk:`vtkDijkstraGraphGeodesicPath` filter is that the
| geodesic path is reversed in the resulting mesh. This is overridden
| in PyVista by default.
|
| Parameters
| ----------
| start_vertex : int
| Vertex index indicating the start point of the geodesic segment.
|
| end_vertex : int
| Vertex index indicating the end point of the geodesic segment.
|
| inplace : bool, default: False
| Whether the input mesh should be replaced with the path. The
| geodesic path is always returned.
|
| keep_order : bool, default: True
| If ``True``, the points of the returned path are guaranteed
| to start with the start vertex (as opposed to the end vertex).
|
| .. versionadded:: 0.32.0
|
| use_scalar_weights : bool, default: False
| If ``True``, use scalar values in the edge weight.
| This only works for point data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| ``PolyData`` object consisting of the line segment between the
| two given vertices. If ``inplace`` is ``True`` this is the
| same object as the input mesh.
|
| Examples
| --------
| Plot the path between two points on the random hills mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> path = hills.geodesic(560, 5820)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills)
| >>> _ = pl.add_mesh(path, line_width=5, color='k')
| >>> pl.show()
|
| See :ref:`geodesic_example` for more examples using this filter.
|
| geodesic_distance(self, start_vertex, end_vertex, use_scalar_weights: 'bool' = False, progress_bar: 'bool' = False)
| Calculate the geodesic distance between two vertices using Dijkstra's algorithm.
|
| Parameters
| ----------
| start_vertex : int
| Vertex index indicating the start point of the geodesic segment.
|
| end_vertex : int
| Vertex index indicating the end point of the geodesic segment.
|
| use_scalar_weights : bool, default: False
| If ``True``, use scalar values in the edge weight.
| This only works for point data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| float
| Length of the geodesic segment.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> length = sphere.geodesic_distance(0, 100)
| >>> f'Length is {length:.3f}'
| 'Length is 0.812'
|
| See :ref:`geodesic_example` for more examples using this filter.
|
| intersection(self, mesh, split_first: 'bool' = True, split_second: 'bool' = True, progress_bar: 'bool' = False)
| Compute the intersection between two meshes.
|
| .. note::
| This method returns the surface intersection from two meshes
| (which often resolves as a line), whereas the
| :func:`PolyDataFilters.boolean_intersection` filter returns
| the "volume" intersection between two closed (manifold)
| meshes.
|
| Parameters
| ----------
| mesh : pyvista.PolyData
| The mesh to intersect with.
|
| split_first : bool, default: True
| If ``True``, return the first input mesh split by the
| intersection with the second input mesh.
|
| split_second : bool, default: True
| If ``True``, return the second input mesh split by the
| intersection with the first input mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The intersection line.
|
| pyvista.PolyData
| The first mesh split along the intersection. Returns the
| original first mesh if ``split_first=False``.
|
| pyvista.PolyData
| The second mesh split along the intersection. Returns the
| original second mesh if ``split_second=False``.
|
| Examples
| --------
| Intersect two spheres, returning the intersection and both spheres
| which have new points/cells along the intersection line.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> s1 = pv.Sphere(phi_resolution=15, theta_resolution=15)
| >>> s2 = s1.copy()
| >>> s2.points += np.array([0.25, 0, 0])
| >>> intersection, s1_split, s2_split = s1.intersection(s2)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(s1, style='wireframe')
| >>> _ = pl.add_mesh(s2, style='wireframe')
| >>> _ = pl.add_mesh(intersection, color='r', line_width=10)
| >>> pl.show()
|
| The mesh splitting takes additional time and can be turned
| off for either mesh individually.
|
| >>> intersection, _, s2_split = s1.intersection(
| ... s2, split_first=False, split_second=True
| ... )
|
| merge(self: 'PolyData', dataset, merge_points: 'bool' = True, tolerance=0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Merge this mesh with one or more datasets.
|
| .. note::
| The behavior of this filter varies from the
| :func:`PolyDataFilters.boolean_union` filter. This filter
| does not attempt to create a manifold mesh and will include
| internal surfaces when two meshes overlap.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the other mesh is also a
| :class:`pyvista.PolyData`, in-place merging via ``+=`` is
| similarly possible.
|
| .. versionchanged:: 0.39.0
| Before version ``0.39.0``, if all input datasets were of type
| :class:`pyvista.PolyData`, the VTK :vtk:`vtkAppendPolyData` and
| :vtk:`vtkCleanPolyData` filters were used to perform merging.
| Otherwise, :func:`DataSetFilters.merge`, which uses the VTK
| :vtk:`vtkAppendFilter` filter, was called.
| To enhance performance and coherence with merging operations
| available for other datasets in pyvista, the merging operation
| has been delegated in ``0.39.0`` to :func:`DataSetFilters.merge`
| only, irrespectively of input datasets types.
| This induced that points ordering can be altered compared to
| previous pyvista versions when merging only PolyData together.
| To obtain similar results as before ``0.39.0`` for multiple PolyData, combine
| :func:`PolyDataFilters.append_polydata` and :func:`PolyDataFilters.clean`.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| .. seealso::
| :func:`PolyDataFilters.append_polydata`
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| PyVista dataset to merge this mesh with.
|
| merge_points : bool, optional
| Merge equivalent points when ``True``.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when ``True`` if the input type is a
| :class:`pyvista.PolyData`. For other input meshes the
| result is a :class:`pyvista.UnstructuredGrid` which makes
| in-place operation impossible.
|
| main_has_priority : bool, optional
| When this parameter is ``True`` and ``merge_points=True``,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| :class:`pyvista.PolyData` if ``dataset`` is a
| :class:`pyvista.PolyData`, otherwise a
| :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere()
| >>> sphere_b = pv.Sphere(center=(0.5, 0, 0))
| >>> merged = sphere_a.merge(sphere_b)
| >>> merged.plot(style='wireframe', color='lightblue')
|
| multi_ray_trace(self: 'PolyData', origins, directions, first_point: 'bool' = False, retry: 'bool' = False)
| Perform multiple ray trace calculations.
|
| This requires a mesh with only triangular faces, an array of
| origin points and an equal sized array of direction vectors to
| trace along.
|
| The embree library used for vectorization of the ray traces is
| known to occasionally return no intersections where the VTK
| implementation would return an intersection. If the result
| appears to be missing some intersection points, set
| ``retry=True`` to run a second pass over rays that returned no
| intersections, using :func:`PolyDataFilters.ray_trace`.
|
| Parameters
| ----------
| origins : array_like[float]
| Starting point for each trace.
|
| directions : array_like[float]
| Direction vector for each trace.
|
| first_point : bool, default: False
| Returns intersection of first point only.
|
| retry : bool, default: False
| Will retry rays that return no intersections using
| :func:`PolyDataFilters.ray_trace`.
|
| Returns
| -------
| intersection_points : numpy.ndarray
| Location of the intersection points. Empty array if no
| intersections.
|
| intersection_rays : numpy.ndarray
| Indices of the ray for each intersection point. Empty array if no
| intersections.
|
| intersection_cells : numpy.ndarray
| Indices of the intersection cells. Empty array if no
| intersections.
|
| Examples
| --------
| Compute the intersection between rays from the origin in
| directions ``[1, 0, 0]``, ``[0, 1, 0]`` and ``[0, 0, 1]``, and
| a sphere with radius 0.5 centered at the origin
|
| >>> import pyvista as pv # doctest:+SKIP
| >>> sphere = pv.Sphere() # doctest:+SKIP
| >>> points, rays, cells = sphere.multi_ray_trace(
| ... [[0, 0, 0]] * 3,
| ... [[1, 0, 0], [0, 1, 0], [0, 0, 1]],
| ... first_point=True,
| ... ) # doctest:+SKIP
| >>> string = ', '.join(
| ... [
| ... f'({point[0]:.3f}, {point[1]:.3f}, {point[2]:.3f})'
| ... for point in points
| ... ]
| ... ) # doctest:+SKIP
| >>> f'Rays intersected at {string}' # doctest:+SKIP
| 'Rays intersected at (0.499, 0.000, 0.000), (0.000, 0.497, 0.000), (0.000, 0.000, 0.500)'
|
| plot_boundaries(self: 'PolyData', edge_color='red', line_width=None, progress_bar: 'bool' = False, **kwargs)
| Plot boundaries of a mesh.
|
| Parameters
| ----------
| edge_color : ColorLike, default: "red"
| The color of the edges when they are added to the plotter.
|
| line_width : int, optional
| Width of the boundary lines.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| All additional keyword arguments will be passed to
| :func:`pyvista.Plotter.add_mesh`.
|
| Returns
| -------
| pyvista.CameraPosition
| List of camera position, focal point, and view up.
| Returned when ``return_cpos`` is ``True``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot_boundaries(line_width=10)
|
| plot_curvature(self, curv_type='mean', **kwargs)
| Plot the curvature.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| One of the following strings indicating curvature type:
|
| * ``'mean'``
| * ``'gaussian'``
| * ``'maximum'``
| * ``'minimum'``
|
| **kwargs : dict, optional
| See :func:`pyvista.plot`.
|
| Returns
| -------
| pyvista.CameraPosition
| List of camera position, focal point, and view up.
| Returned when ``return_cpos`` is ``True``.
|
| Examples
| --------
| Plot the Gaussian curvature of an example mesh. Override the
| default scalar bar range as the mesh edges report high
| curvature.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot_curvature(
| ... curv_type='gaussian', smooth_shading=True, clim=[0, 1]
| ... )
|
| plot_normals(self: 'PolyData', show_mesh: 'bool' = True, mag=1.0, flip: 'bool' = False, use_every=1, faces: 'bool' = False, color=None, **kwargs)
| Plot the point normals of a mesh.
|
| Parameters
| ----------
| show_mesh : bool, default: True
| Plot the mesh itself.
|
| mag : float, default: 1.0
| Size magnitude of the normal arrows.
|
| flip : bool, default: False
| Flip the normal direction when ``True``.
|
| use_every : int, default: 1
| Display every nth normal. By default every normal is
| displayed. Display every 10th normal by setting this
| parameter to 10.
|
| faces : bool, default: False
| Plot face normals instead of the default point normals.
|
| color : ColorLike, optional
| Color of the arrows. Defaults to
| :attr:`pyvista.plotting.themes.Theme.edge_color`.
|
| **kwargs : dict, optional
| All additional keyword arguments will be passed to
| :func:`pyvista.Plotter.add_mesh`.
|
| Returns
| -------
| pyvista.CameraPosition
| List of camera position, focal point, and view up.
| Returned when ``return_cpos`` is ``True``.
|
| Examples
| --------
| Plot the point normals of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=10, theta_resolution=10)
| >>> sphere.plot_normals(mag=0.1, show_edges=True)
|
| Plot the face normals of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(phi_resolution=10, theta_resolution=10)
| >>> sphere.plot_normals(mag=0.1, faces=True, show_edges=True)
|
| project_points_to_plane(self: 'PolyData', origin: 'VectorLike[float] | None' = None, normal: 'VectorLike[float] | _NormalsLiteral | None' = None, inplace: 'bool' = False, plane: 'PolyData | None' = None)
| Project points of this mesh to a plane.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| Parameters
| ----------
| origin : VectorLike[float], optional
| Plane origin. Defaults to the approximate center of the
| input mesh minus half the length of the input mesh in the
| direction of the normal.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector for the plane's normal. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'z'`` direction is used by default.
|
| inplace : bool, default: False
| Whether to overwrite the original mesh with the projected
| points.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to project to. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| The points of this mesh projected onto a plane.
|
| See Also
| --------
| :ref:`project_plane_example`
| :ref:`project_points_tessellate_example`
|
| Examples
| --------
| Flatten a sphere to the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> projected = sphere.project_points_to_plane()
|
| Plot the projected sphere along with the original.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(projected, show_edges=True, line_width=3)
| >>> _ = pl.add_mesh(sphere)
| >>> _ = pl.show_grid()
| >>> cpos = pv.CameraPosition(
| ... position=(2.5, 2.5, 1.1),
| ... focal_point=(0.0, 0.0, -0.3),
| ... viewup=(-0.25, -0.25, 1.0),
| ... )
| >>> pl.camera_position = cpos
| >>> pl.show()
|
| protein_ribbon(self, progress_bar: 'bool' = False)
| Generate protein ribbon.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Generated protein ribbon.
|
| Examples
| --------
| Generate protein ribbon.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> tgqp = examples.download_3gqp()
| >>> ribbon = tgqp.protein_ribbon()
| >>> ribbon.plot()
|
| ray_trace(self: 'PolyData', origin, end_point, first_point: 'bool' = False, plot: 'bool' = False, off_screen=None)
| Perform a single ray trace calculation.
|
| This requires a mesh and a line segment defined by an origin
| and end_point.
|
| .. warning::
|
| This filter uses the mesh's :attr:`~pyvista.PolyData.obbTree` property internally to
| compute the intersection. Since the obb tree is cached, the intersection may not be
| valid if the mesh's geometry is modified in between filter calls.
|
| Parameters
| ----------
| origin : sequence[float]
| Start of the line segment.
|
| end_point : sequence[float]
| End of the line segment.
|
| first_point : bool, default: False
| Returns intersection of first point only.
|
| plot : bool, default: False
| Whether to plot the ray trace results.
|
| off_screen : bool, optional
| Plots off screen when ``plot=True``. Used for unit testing.
|
| Returns
| -------
| intersection_points : numpy.ndarray
| Location of the intersection points. Empty array if no
| intersections.
|
| intersection_cells : numpy.ndarray
| Indices of the intersection cells. Empty array if no
| intersections.
|
| See Also
| --------
| :ref:`ray_trace_moeller_example`
| Example of ray-tracing using the Moeller-Trumbore intersection algorithm.
|
| Examples
| --------
| Compute the intersection between a ray from the origin to
| ``[1, 0, 0]`` and a sphere with radius 0.5 centered at the
| origin.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> point, cell = sphere.ray_trace([0, 0, 0], [1, 0, 0], first_point=True)
| >>> f'Intersected at {point[0]:.3f} {point[1]:.3f} {point[2]:.3f}'
| 'Intersected at 0.499 0.000 0.000'
|
| Show a plot of the ray trace.
|
| >>> point, cell = sphere.ray_trace([0, 0, 0], [1, 0, 0], plot=True)
|
| See :ref:`ray_trace_example` for more examples using this filter.
|
| reconstruct_surface(self, nbr_sz=None, sample_spacing=None, progress_bar: 'bool' = False)
| Reconstruct a surface from the points in this dataset.
|
| This filter takes a list of points assumed to lie on the
| surface of a solid 3D object. A signed measure of the distance
| to the surface is computed and sampled on a regular grid. The
| grid can then be contoured at zero to extract the surface. The
| default values for neighborhood size and sample spacing should
| give reasonable results for most uses but can be set if
| desired.
|
| This is helpful when generating surfaces from point clouds and
| is more reliable than :func:`DataSetFilters.delaunay_3d`.
|
| Parameters
| ----------
| nbr_sz : int, optional
| Specify the number of neighbors each point has, used for
| estimating the local surface orientation.
|
| The default value of 20 should be fine for most
| applications, higher values can be specified if the spread
| of points is uneven. Values as low as 10 may yield
| adequate results for some surfaces. Higher values cause
| the algorithm to take longer and will cause
| errors on sharp boundaries.
|
| sample_spacing : float, optional
| The spacing of the 3D sampling grid. If not set, a
| reasonable guess will be made.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Reconstructed surface.
|
| Examples
| --------
| Create a point cloud out of a sphere and reconstruct a surface
| from it.
|
| >>> import pyvista as pv
| >>> points = pv.wrap(pv.Sphere().points)
| >>> surf = points.reconstruct_surface()
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(points)
| >>> _ = pl.add_title('Point Cloud of 3D Surface')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(surf, color=True, show_edges=True)
| >>> _ = pl.add_title('Reconstructed Surface')
| >>> pl.show()
|
| See :ref:`surface_reconstruction_example` for more examples
| using this filter.
|
| remove_points(self, remove, mode='any', keep_scalars: 'bool' = True, inplace: 'bool' = False)
| Rebuild a mesh by removing points.
|
| Only valid for all-triangle meshes.
|
| Parameters
| ----------
| remove : sequence[bool | int]
| If remove is a bool array, points that are ``True`` will
| be removed. Otherwise, it is treated as a list of
| indices.
|
| mode : str, default: "any"
| When ``'all'``, only faces containing all points flagged
| for removal will be removed.
|
| keep_scalars : bool, default: True
| When ``True``, point and cell scalars will be passed on to
| the new mesh.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PolyData
| Mesh without the points flagged for removal.
|
| numpy.ndarray
| Indices of new points relative to the original mesh.
|
| Examples
| --------
| Remove the first 100 points from a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> reduced_sphere, ridx = sphere.remove_points(range(100, 250))
| >>> reduced_sphere.plot(show_edges=True, line_width=3)
|
| remove_unused_points(self: '_PolyDataType', *, inplace: 'bool' = False) -> '_PolyDataType'
| Remove points which are not used by any cells.
|
| This filter is similar to :meth:`clean` but does `not` merge points or convert cells.
| The point order is also unchanged by this filter.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy is returned.
|
| See Also
| --------
| pyvista.UnstructuredGridFilters.remove_unused_points
|
| Returns
| -------
| PolyData
| Mesh with unused points removed.
|
| Examples
| --------
| Create :class:`~pyvista.PolyData` with three points. The first two points are coincident
| and associated with :attr:`~pyvista.CellType.VERTEX` cells, and the third point is
| "unused" and not associated with any cells.
|
| >>> import pyvista as pv
| >>> points = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]
| >>> faces = [1, 0, 1, 1]
| >>> poly = pv.PolyData(points, faces)
| >>> poly
| PolyData (...)
| N Cells: 2
| N Points: 3
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 1.000e+00
| N Arrays: 0
|
| Since the third point is unused, we can remove it. Note that coincident points are `not`
| merged by this filter, so the two vertex points are kept as-is.
|
| >>> poly = poly.remove_unused_points()
| >>> poly
| PolyData (...)
| N Cells: 2
| N Points: 2
| N Strips: 0
| X Bounds: 0.000e+00, 0.000e+00
| Y Bounds: 0.000e+00, 0.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| N Arrays: 0
|
| ribbon(self, width=None, scalars=None, angle=0.0, factor=2.0, normal=None, tcoords: 'bool | str' = False, preference='points', progress_bar: 'bool' = False)
| Create a ribbon of the lines in this dataset.
|
| .. note::
| If there are no lines in the input dataset, then the output
| will be an empty :class:`pyvista.PolyData` mesh.
|
| Parameters
| ----------
| width : float, optional
| Set the "half" width of the ribbon. If the width is
| allowed to vary, this is the minimum width. The default is
| 10% the length.
|
| scalars : str, optional
| String name of the scalars array to use to vary the ribbon
| width. This is only used if a scalars array is specified.
|
| angle : float, optional
| Angle in degrees of the offset angle of the ribbon from
| the line normal. The default is 0.0.
|
| factor : float, optional
| Set the maximum ribbon width in terms of a multiple of the
| minimum width. The default is 2.0.
|
| normal : sequence[float], optional
| Normal to use as default.
|
| tcoords : bool, str, optional
| If ``True``, generate texture coordinates along the
| ribbon. This can also be specified to generate the texture
| coordinates with either ``'length'`` or ``'normalized'``.
|
| preference : str, optional
| The field preference when searching for the scalars array by
| name.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Ribbon mesh. Empty if there are no lines in the input dataset.
|
| Examples
| --------
| Convert a line to a ribbon and plot it.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> n = 1000
| >>> theta = np.linspace(-10 * np.pi, 10 * np.pi, n)
| >>> z = np.linspace(-2, 2, n)
| >>> r = z**2 + 1
| >>> x = r * np.sin(theta)
| >>> y = r * np.cos(theta)
| >>> points = np.column_stack((x, y, z))
| >>> pdata = pv.PolyData(points)
| >>> pdata.lines = np.hstack((n, range(n)))
| >>> pdata['distance'] = range(n)
| >>> ribbon = pdata.ribbon(width=0.2)
| >>> ribbon.plot(show_scalar_bar=False)
|
| ruled_surface(self, *, resolution: 'VectorLike[int] | None' = None, progress_bar: 'bool' = False)
| Create a ruled surface from a polyline.
|
| .. versionadded:: 0.45.0
|
| This filter is a filter that generates a surface from
| a set of lines. The lines are assumed to be "parallel"
| in the sense that they do not intersect and remain
| somewhat close to one another. A surface is generated
| by connecting the points defining each pair of lines
| with straight lines. This creates a strip for each pair
| of lines (i.e., a triangulation is created from two
| generating lines). The filter can handle an arbitrary
| number of lines, with lines i and i+1 assumed
| connected. Note that there are several different
| approaches for creating the ruled surface, the method
| for creating the surface can either use the input points
| or resample from the polylines (using a user-specified
| resolution).
|
| This filter implements :vtk:`vtkRuledSurfaceFilter`.
|
| Parameters
| ----------
| resolution : int, default: (1, 1)
| Set the number of points in the output polyline.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Ruled surface.
|
| Examples
| --------
| Create a ruled surface from a polyline.
|
| >>> import pyvista as pv
| >>> pl = pv.Plotter()
| >>> poly = pv.PolyData(
| ... [[0, 0, 1], [1, 0, 0], [0, 1, 0], [1, 1, 1]],
| ... lines=[[2, 0, 1], [2, 2, 3]],
| ... force_float=False,
| ... )
| >>> surface = poly.ruled_surface(resolution=(21, 21))
| >>> _ = pl.add_mesh(surface, show_edges=True)
| >>> pl.show()
|
| smooth(self, n_iter=20, relaxation_factor=0.01, convergence=0.0, edge_angle=15, feature_angle=45, boundary_smoothing: 'bool' = True, feature_smoothing: 'bool' = False, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Adjust point coordinates using Laplacian smoothing.
|
| The effect is to "relax" the mesh, making the cells better shaped and
| the vertices more evenly distributed.
|
| Parameters
| ----------
| n_iter : int, default: 20
| Number of iterations for Laplacian smoothing.
|
| relaxation_factor : float, default: 0.01
| Relaxation factor controls the amount of displacement in a single
| iteration. Generally a lower relaxation factor and higher number of
| iterations is numerically more stable.
|
| convergence : float, default: 0.0
| Convergence criterion for the iteration process. Smaller numbers
| result in more smoothing iterations. Range from (0 to 1).
|
| edge_angle : float, default: 15
| Edge angle to control smoothing along edges (either interior or boundary).
|
| feature_angle : float, default: 45
| Feature angle for sharp edge identification.
|
| boundary_smoothing : bool, default: True
| Flag to control smoothing of boundary edges. When ``True``,
| boundary edges remain fixed.
|
| feature_smoothing : bool, default: False
| Flag to control smoothing of feature edges. When ``True``,
| boundary edges remain fixed as defined by ``feature_angle`` and
| ``edge_angle``.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Smoothed mesh.
|
| Examples
| --------
| Smooth the edges of an all triangular cube
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(5)
| >>> smooth_cube = cube.smooth(n_iter=1000, feature_smoothing=False)
| >>> n_edge_cells = cube.extract_feature_edges().n_cells
| >>> n_smooth_cells = smooth_cube.extract_feature_edges().n_cells
| >>> f'Sharp Edges on Cube: {n_edge_cells}'
| 'Sharp Edges on Cube: 384'
| >>> f'Sharp Edges on Smooth Cube: {n_smooth_cells}'
| 'Sharp Edges on Smooth Cube: 12'
| >>> smooth_cube.plot()
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| smooth_taubin(self, n_iter=20, pass_band=0.1, edge_angle=15.0, feature_angle=45.0, boundary_smoothing: 'bool' = True, feature_smoothing: 'bool' = False, non_manifold_smoothing: 'bool' = False, normalize_coordinates: 'bool' = False, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Smooth a PolyData DataSet with Taubin smoothing.
|
| This filter allows you to smooth the mesh as in the Laplacian smoothing
| implementation in :func:`smooth() <PolyDataFilters.smooth>`. However,
| unlike Laplacian smoothing the surface does not "shrink" since this
| filter relies on an alternative approach to smoothing. This filter is
| more akin to a low pass filter where undesirable high frequency features
| are removed.
|
| This PyVista filter uses the VTK :vtk:`vtkWindowedSincPolyDataFilter`
| filter.
|
| Parameters
| ----------
| n_iter : int, default: 20
| This is the degree of the polynomial used to approximate the
| windowed sync function. This is generally much less than the number
| needed by :func:`smooth() <PolyDataFilters.smooth>`.
|
| pass_band : float, default: 0.1
| The passband value for the windowed sinc filter. This should be
| between 0 and 2, where lower values cause more smoothing.
|
| edge_angle : float, default: 15.0
| Edge angle to control smoothing along edges (either interior or
| boundary).
|
| feature_angle : float, default: 45.0
| Feature angle for sharp edge identification.
|
| boundary_smoothing : bool, default: True
| Flag to control smoothing of boundary edges. When ``True``,
| boundary edges remain fixed.
|
| feature_smoothing : bool, default: False
| Flag to control smoothing of feature edges. When ``True``,
| boundary edges remain fixed as defined by ``feature_angle`` and
| ``edge_angle``.
|
| non_manifold_smoothing : bool, default: False
| Smooth non-manifold points.
|
| normalize_coordinates : bool, default: False
| Flag to control coordinate normalization. To improve the
| numerical stability of the solution and minimize the scaling of the
| translation effects, the algorithm can translate and scale the
| position coordinates to within the unit cube ``[-1, 1]``, perform the
| smoothing, and translate and scale the position coordinates back to
| the original coordinate frame.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Smoothed mesh.
|
| Notes
| -----
| For maximum performance, do not enable ``feature_smoothing`` or
| ``boundary_smoothing``. ``feature_smoothing`` is especially expensive.
|
| References
| ----------
| See `Optimal Surface Smoothing as Filter Design
| <https://dl.acm.org/doi/pdf/10.1145/218380.218473>`_ for details
| regarding the implementation of Taubin smoothing.
|
| Examples
| --------
| Smooth the example bone mesh. Here, it's necessary to subdivide the
| mesh to increase the number of faces as the original mesh is so coarse.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_foot_bones().subdivide(2)
| >>> smoothed_mesh = mesh.smooth_taubin()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_text('Original Mesh')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(smoothed_mesh)
| >>> _ = pl.add_text('Smoothed Mesh')
| >>> pl.show()
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| strip(self, join: 'bool' = False, max_length=1000, pass_cell_data: 'bool' = False, pass_cell_ids: 'bool' = False, pass_point_ids: 'bool' = False, progress_bar: 'bool' = False)
| Strip poly data cells.
|
| Generates triangle strips and/or poly-lines from input
| polygons, triangle strips, and lines.
|
| Polygons are assembled into triangle strips only if they are
| triangles; other types of polygons are passed through to the
| output and not stripped. (Use ``triangulate`` filter to
| triangulate non-triangular polygons prior to running this
| filter if you need to strip all the data.) The filter will
| pass through (to the output) vertices if they are present in
| the input polydata.
|
| Also note that if triangle strips or polylines are defined in
| the input they are passed through and not joined nor
| extended. (If you wish to strip these use ``triangulate``
| filter to fragment the input into triangles and lines prior to
| running this filter.)
|
| This filter implements :vtk:`vtkStripper`.
|
| Parameters
| ----------
| join : bool, default: False
| If ``True``, the output polygonal segments will be joined
| if they are contiguous. This is useful after slicing a
| surface.
|
| max_length : int, default: 1000
| Specify the maximum number of triangles in a triangle
| strip, and/or the maximum number of lines in a poly-line.
|
| pass_cell_data : bool, default: False
| Enable/Disable passing of the CellData in the input to the
| output as FieldData. Note the field data is transformed.
|
| pass_cell_ids : bool, default: False
| If ``True``, the output polygonal dataset will have a
| celldata array that holds the cell index of the original
| 3D cell that produced each output cell. This is useful for
| picking. The default is ``False`` to conserve memory.
|
| pass_point_ids : bool, default: False
| If ``True``, the output polygonal dataset will have a
| pointdata array that holds the point index of the original
| vertex that produced each output vertex. This is useful
| for picking. The default is ``False`` to conserve memory.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Stripped mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> slc = mesh.slice(normal='z', origin=(0, 0, -10))
| >>> stripped = slc.strip()
| >>> stripped.n_cells
| 1
| >>> stripped.plot(show_edges=True, line_width=3)
|
| subdivide(self, nsub, subfilter='linear', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Increase the number of triangles in a single, connected triangular mesh.
|
| Uses one of the following vtk subdivision filters to subdivide a mesh:
|
| * :vtk:`vtkButterflySubdivisionFilter`
| * :vtk:`vtkLoopSubdivisionFilter`
| * :vtk:`vtkLinearSubdivisionFilter`
|
| Linear subdivision results in the fastest mesh subdivision,
| but it does not smooth mesh edges, but rather splits each
| triangle into 4 smaller triangles.
|
| Butterfly and loop subdivision perform smoothing when
| dividing, and may introduce artifacts into the mesh when
| dividing.
|
| .. note::
| Subdivision filter sometimes fails for multiple part
| meshes. The input should be one connected mesh.
|
| Parameters
| ----------
| nsub : int
| Number of subdivisions. Each subdivision creates 4 new
| triangles, so the number of resulting triangles is
| ``nface*4**nsub`` where ``nface`` is the current number of
| faces.
|
| subfilter : str, default: "linear"
| Can be one of the following:
|
| * ``'butterfly'``
| * ``'loop'``
| * ``'linear'``
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Subdivided mesh.
|
| Examples
| --------
| First, create an example coarse sphere mesh and plot it.
|
| >>> from pyvista import examples
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(phi_resolution=10, theta_resolution=10)
| >>> mesh.plot(show_edges=True, line_width=3)
|
| Subdivide the sphere mesh using linear subdivision.
|
| >>> submesh = mesh.subdivide(1, 'linear')
| >>> submesh.plot(show_edges=True, line_width=3)
|
| Subdivide the sphere mesh using loop subdivision.
|
| >>> submesh = mesh.subdivide(1, 'loop')
| >>> submesh.plot(show_edges=True, line_width=3)
|
| Subdivide the sphere mesh using butterfly subdivision.
|
| >>> submesh = mesh.subdivide(1, 'butterfly')
| >>> submesh.plot(show_edges=True, line_width=3)
|
| subdivide_adaptive(self, max_edge_len=None, max_tri_area=None, max_n_tris=None, max_n_passes=None, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Increase the number of triangles in a triangular mesh based on edge and/or area metrics.
|
| This filter uses a simple case-based, multi-pass approach to
| repeatedly subdivide the input triangle mesh to meet the area
| and/or edge length criteria. New points may be inserted only
| on edges; depending on the number of edges to be subdivided a
| different number of triangles are inserted ranging from two
| (i.e., two triangles replace the original one) to four.
|
| Point and cell data is treated as follows: The cell data from
| a parent triangle is assigned to its subdivided
| children. Point data is interpolated along edges as the edges
| are subdivided.
|
| This filter retains mesh watertightness if the mesh was
| originally watertight; and the area and max triangles criteria
| are not used.
|
| Parameters
| ----------
| max_edge_len : float, optional
| The maximum edge length that a triangle may have. Edges
| longer than this value are split in half and the
| associated triangles are modified accordingly.
|
| max_tri_area : float, optional
| The maximum area that a triangle may have. Triangles
| larger than this value are subdivided to meet this
| threshold. Note that if this criterion is used it may
| produce non-watertight meshes as a result.
|
| max_n_tris : int, optional
| The maximum number of triangles that can be created. If
| the limit is hit, it may result in premature termination
| of the algorithm and the results may be less than
| satisfactory (for example non-watertight meshes may be
| created). By default, the limit is set to a very large
| number (i.e., no effective limit).
|
| max_n_passes : int, optional
| The maximum number of passes (i.e., levels of
| subdivision). If the limit is hit, then the subdivision
| process stops and additional passes (needed to meet other
| criteria) are aborted. The default limit is set to a very
| large number (i.e., no effective limit).
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Subdivided mesh.
|
| Examples
| --------
| First, load the example airplane mesh and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.PolyData(examples.planefile)
| >>> mesh.plot(show_edges=True, line_width=3)
|
| Subdivide the mesh
|
| >>> submesh = mesh.subdivide_adaptive(max_n_passes=2)
| >>> submesh.plot(show_edges=True)
|
| triangulate(self, *, pass_verts: 'bool' = False, pass_lines: 'bool' = False, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| pass_verts : bool, default: False
| Whether vertices cells are passed to the output PolyData.
|
| .. versionadded:: 0.45.0
|
| pass_lines : bool, default: False
| Whether lines cells are passed to the output PolyData.
|
| .. versionadded:: 0.45.0
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| triangulate_contours(self: '_PolyDataType', display_errors: 'bool' = False, progress_bar: 'bool' = False) -> '_PolyDataType'
| Triangulate and fill all 2D contours to create polygons.
|
| .. versionadded:: 0.44.0
|
| This filter will generate triangles to fill all of the 2D contours
| in its input. The input to the filter is a set of lines (not polylines)
| which when joined form loops. The contours may be concave, and may even
| contain holes i.e. a contour may contain an internal contour that is
| wound in the opposite direction (as compared to the outer polygon
| normal) to indicate that it is a hole.
|
| .. note::
|
| This filter will assume that the input polygons lie in the same
| plane and will not perform any projection or transformation of the
| input data. You may need to project your data to a plane before
| using this filter.
|
| .. warning::
|
| The triangulation of is done in O(n) time for simple convex inputs,
| but for non-convex inputs the worst-case time is O(n^2*m^2) where n
| is the number of points and m is the number of holes. The best
| triangulation algorithms, in contrast, are O(n log n). The
| resulting triangles may be quite narrow, the algorithm does not
| attempt to produce high-quality triangles.
|
| Parameters
| ----------
| display_errors : bool, default: False
| Generate errors when the triangulation fails. Note that
| triangulation failures are often minor, because they involve tiny
| triangles that are too small to see.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Raises
| ------
| RuntimeError
| If the mesh does not contain lines.
|
| Returns
| -------
| pyvista.PolyData
| Triangulated mesh with the filled contours.
|
| Examples
| --------
| Create banded contour and fill.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.download_st_helens()
| >>> contours = image.contour([1302.3334, 1922.6666])
| >>> filled = contours.triangulate_contours()
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(image, show_scalar_bar=False)
| >>> _ = pl.add_mesh(contours, color='black')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(contours, color='black')
| >>> _ = pl.add_mesh(filled, color='red')
| >>> pl.link_views()
| >>> pl.view_xy()
| >>> pl.show()
|
| tube(self, radius=None, scalars=None, capping: 'bool' = True, n_sides=20, radius_factor=10.0, absolute: 'bool' = False, preference='point', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Generate a tube around each input line.
|
| The radius of the tube can be set to linearly vary with a
| scalar value.
|
| Parameters
| ----------
| radius : float, optional
| Minimum tube radius (minimum because the tube radius may
| vary).
|
| scalars : str, optional
| Scalars array by which the radius varies.
|
| capping : bool, default: True
| Turn on/off whether to cap the ends with polygons.
|
| n_sides : int, default: 20
| Set the number of sides for the tube. Minimum of 3.
|
| radius_factor : float, default: 10.0
| Maximum tube radius in terms of a multiple of the minimum
| radius.
|
| absolute : bool, default: False
| Vary the radius with values from scalars in absolute units.
|
| preference : str, default: 'point'
| The field preference when searching for the scalars array by
| name.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Tube-filtered mesh.
|
| Examples
| --------
| Convert a single line to a tube.
|
| >>> import pyvista as pv
| >>> line = pv.Line()
| >>> tube = line.tube(radius=0.02)
| >>> f'Line Cells: {line.n_cells}'
| 'Line Cells: 1'
| >>> f'Tube Cells: {tube.n_cells}'
| 'Tube Cells: 22'
| >>> tube.plot(color='lightblue')
|
| See :ref:`create_spline_example` for more examples using this filter.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkPolyData:
|
| AddCellReference(...)
| AddCellReference(self, cellId:int) -> None
| C++: void AddCellReference(vtkIdType cellId)
|
| Add references to cell in cell structure. This means the links
| from the cell's points to the cell are modified. Memory is not
| extended. Use the method ResizeCellList() to resize the link list
| from a point to its using cells. (This operator assumes
| BuildLinks() has been called.) Use this method only when the
| dataset is set as Editable.
|
| AddReferenceToCell(...)
| AddReferenceToCell(self, ptId:int, cellId:int) -> None
| C++: void AddReferenceToCell(vtkIdType ptId, vtkIdType cellId)
|
| Add a reference to a cell in a particular point's link list. (You
| may also consider using AddCellReference() to add the references
| from all the cell's points to the cell.) This operator does not
| realloc memory; use the operator ResizeCellList() to do this if
| necessary. Use this method only when the dataset is set as
| Editable.
|
| Allocate(...)
| Allocate(self, numCells:int=1000, extSize:int=1000) -> None
| C++: void Allocate(vtkIdType numCells=1000, int extSize=1000)
| Allocate(self, inPolyData:vtkPolyData, numCells:int=1000,
| extSize:int=1000) -> None
| C++: void Allocate(vtkPolyData *inPolyData,
| vtkIdType numCells=1000, int extSize=1000)
|
| Method allocates initial storage for vertex, line, polygon, and
| triangle strip arrays. Use this method before the method
| PolyData::InsertNextCell(). (Or, provide vertex, line, polygon,
| and triangle strip cell arrays). extSize is no longer used.
|
| AllocateCopy(...)
| AllocateCopy(self, pd:vtkPolyData) -> bool
| C++: bool AllocateCopy(vtkPolyData *pd)
|
| Preallocate memory for the internal cell arrays such that they
| are the same size as those in pd.
|
| Existing data is not preserved and the number of cells is set to
| zero.
|
| @return True if allocation succeeds.
|
| AllocateEstimate(...)
| AllocateEstimate(self, numCells:int, maxCellSize:int) -> bool
| C++: bool AllocateEstimate(vtkIdType numCells,
| vtkIdType maxCellSize)
| AllocateEstimate(self, numVerts:int, maxVertSize:int,
| numLines:int, maxLineSize:int, numPolys:int, maxPolySize:int,
| numStrips:int, maxStripSize:int) -> bool
| C++: bool AllocateEstimate(vtkIdType numVerts,
| vtkIdType maxVertSize, vtkIdType numLines,
| vtkIdType maxLineSize, vtkIdType numPolys,
| vtkIdType maxPolySize, vtkIdType numStrips,
| vtkIdType maxStripSize)
|
| Preallocate memory for the internal cell arrays. Each of the
| internal cell arrays (verts, lines, polys, and strips) will be
| resized to holdnumCells cells of size maxCellSize.
|
| Existing data is not preserved and the number of cells is set to
| zero.
|
| @return True if allocation succeeds.
|
| AllocateExact(...)
| AllocateExact(self, numCells:int, connectivitySize:int) -> bool
| C++: bool AllocateExact(vtkIdType numCells,
| vtkIdType connectivitySize)
| AllocateExact(self, numVerts:int, vertConnSize:int, numLines:int,
| lineConnSize:int, numPolys:int, polyConnSize:int,
| numStrips:int, stripConnSize:int) -> bool
| C++: bool AllocateExact(vtkIdType numVerts,
| vtkIdType vertConnSize, vtkIdType numLines,
| vtkIdType lineConnSize, vtkIdType numPolys,
| vtkIdType polyConnSize, vtkIdType numStrips,
| vtkIdType stripConnSize)
|
| Preallocate memory for the internal cell arrays. Each of the
| internal cell arrays (verts, lines, polys, and strips) will be
| resized to holdnumCells cells and connectivitySize pointIds.
|
| Existing data is not preserved and the number of cells is set to
| zero.
|
| @return True if allocation succeeds.
|
| AllocateProportional(...)
| AllocateProportional(self, pd:vtkPolyData, ratio:float) -> bool
| C++: bool AllocateProportional(vtkPolyData *pd, double ratio)
|
| Preallocate memory for the internal cell arrays such that they
| are proportional to those in pd by a factor of ratio (for
| instance,ratio = 2 allocates twice as many cells).
|
| Existing data is not preserved and the number of cells is set to
| zero.
|
| @return True if allocation succeeds.
|
| BuildCells(...)
| BuildCells(self) -> None
| C++: void BuildCells()
|
| Create data structure that allows random access of cells.
| BuildCells is expensive but necessary to make use of the faster
| non-virtual implementations of GetCell/GetCellPoints. One may
| check if cells need to be built via NeedToBuilds before invoking.
| Cells always need to be built/re-built after low level direct
| modifications to verts, lines, polys or strips cell arrays.
|
| BuildLinks(...)
| BuildLinks(self, initialSize:int=0) -> None
| C++: void BuildLinks(int initialSize=0)
|
| Create upward links from points to cells that use each point.
| Enables topologically complex queries. Normally the links array
| is allocated based on the number of points in the vtkPolyData.
| The optional initialSize parameter can be used to allocate a
| larger size initially.
|
| ComputeCellsBounds(...)
| ComputeCellsBounds(self) -> None
| C++: void ComputeCellsBounds()
|
| Compute the (X, Y, Z) bounds of the data. Note that the method
| only considers points that are used by cells. This is done for
| usability and historical reasons.
|
| IMPORTANT
|
| Until vtk 9.0.1, vtkPolyData::ComputeBounds() used to ignore
| points that do not belong to any cell. That was not consistent
| with other vtkPointSet subclasses and thus was error prone. See
| this ParaView issue
| https://gitlab.kitware.com/paraview/paraview/-/issues/20354 Now
| it defers to vtkPointSet::ComputeBounds() so
| vtkPolyData::GetBounds() may not return the same bounds as
| before. This behavior is probably the one you want when using
| bounds.
|
| The previous behavior is still available through
| vtkPolyData::ComputeCellsBounds() and
| vtkPolyData::GetCellsBounds(). This is mainly used for rendering
| purpose.
|
| CopyCells(...)
| CopyCells(self, pd:vtkPolyData, idList:vtkIdList,
| locator:vtkIncrementalPointLocator=...) -> None
| C++: void CopyCells(vtkPolyData *pd, vtkIdList *idList,
| vtkIncrementalPointLocator *locator=nullptr)
|
| Copy cells listed in idList from pd, including points, point
| data, and cell data. This method assumes that point and cell
| data have been allocated. If you pass in a point locator, then
| the points won't be duplicated in the output. This requires the
| use of an incremental point locator.
|
| CopyStructure(...)
| CopyStructure(self, ds:vtkDataSet) -> None
| C++: void CopyStructure(vtkDataSet *ds) override;
|
| Copy the geometric and topological structure of an input poly
| data object.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| DeleteCell(...)
| DeleteCell(self, cellId:int) -> None
| C++: void DeleteCell(vtkIdType cellId)
|
| DeleteCells(...)
| DeleteCells(self) -> None
| C++: void DeleteCells()
|
| Release data structure that allows random access of the cells.
| This must be done before a 2nd call to BuildLinks(). DeleteCells
| implicitly deletes the links as well since they are no longer
| valid.
|
| DeleteLinks(...)
| DeleteLinks(self) -> None
| C++: void DeleteLinks()
|
| Release the upward links from point to cells that use each point.
|
| DeletePoint(...)
| DeletePoint(self, ptId:int) -> None
| C++: void DeletePoint(vtkIdType ptId)
|
| Mark a point/cell as deleted from this vtkPolyData. Use this
| method only when the dataset is set as Editable.
|
| ExtendedNew(...)
| ExtendedNew() -> vtkPolyData
| C++: static vtkPolyData *ExtendedNew()
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated. The
| memory size returned is guaranteed to be greater than or equal to
| the memory required to represent the data (e.g., extra space in
| arrays, etc. are not included in the return value). THIS METHOD
| IS THREAD SAFE.
|
| GetCell(...)
| GetCell(self, cellId:int) -> vtkCell
| C++: vtkCell *GetCell(vtkIdType cellId) override;
| GetCell(self, cellId:int, cell:vtkGenericCell) -> None
| C++: void GetCell(vtkIdType cellId, vtkGenericCell *cell)
| override;
| GetCell(self, cellId:int, pts:(int, ...)) -> int
| C++: unsigned char GetCell(vtkIdType cellId,
| const vtkIdType *&pts)
| GetCell(self, i:int, j:int, k:int) -> vtkCell
| C++: virtual vtkCell *GetCell(int i, int j, int k)
|
| This method always return a `vtkEmptyCell`, as there is no cell
| in a `vtkPointSet`.
|
| GetCellBounds(...)
| GetCellBounds(self, cellId:int, bounds:[float, float, float,
| float, float, float]) -> None
| C++: void GetCellBounds(vtkIdType cellId, double bounds[6])
| override;
|
| Get the bounds of the cell with cellId such that: 0 <= cellId <
| NumberOfCells. A subclass may be able to determine the bounds of
| cell without using an expensive GetCell() method. A default
| implementation is provided that actually uses a GetCell() call.
| This is to ensure the method is available to all datasets.
| Subclasses should override this method to provide an efficient
| implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetCellEdgeNeighbors(...)
| GetCellEdgeNeighbors(self, cellId:int, p1:int, p2:int,
| cellIds:vtkIdList) -> None
| C++: void GetCellEdgeNeighbors(vtkIdType cellId, vtkIdType p1,
| vtkIdType p2, vtkIdList *cellIds)
|
| Get the neighbors at an edge. More efficient than the general
| GetCellNeighbors(). Assumes links have been built (with
| BuildLinks()), and looks specifically for edge neighbors.
|
| GetCellIdRelativeToCellArray(...)
| GetCellIdRelativeToCellArray(self, cellId:int) -> int
| C++: vtkIdType GetCellIdRelativeToCellArray(vtkIdType cellId)
|
| Maps the cell at position `cellId` inside the `vtkPolyData` to
| its location in the corresponding cell array. For instance, if
| cell `cellId` is a line, then this method returns the position of
| this cell in the `Lines` cell array.
|
| GetCellNeighbors(...)
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds) override;
|
| Topological inquiry to get all cells using list of points
| exclusive of cell specified (e.g., cellId). Note that the list
| consists of only cells that use ALL the points provided. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetCellPoints(...)
| GetCellPoints(self, cellId:int, ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
| override;
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...)) -> int
| C++: unsigned char GetCellPoints(vtkIdType cellId,
| vtkIdType &npts, vtkIdType const *&pts)
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...),
| ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts, vtkIdList *ptIds) override;
|
| Copy a cells point ids into list provided. (Less efficient.)
|
| GetCellSize(...)
| GetCellSize(self, cellId:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType cellId) override;
|
| This method always returns 1, as all cells are point in a pure
| `vtkPointSet`.
|
| GetCellType(...)
| GetCellType(self, cellId:int) -> int
| C++: int GetCellType(vtkIdType cellId) override;
|
| This method always returns `VTK_EMPTY_CELL`, as there is no cell
| in a `vtkPointSet`.
|
| GetCellsBounds(...)
| GetCellsBounds(self, bounds:[float, float, float, float, float,
| float]) -> None
| C++: void GetCellsBounds(double bounds[6])
|
| Get the cells bounds. Internally calls ComputeCellsBounds().
| @sa ComputeCellsBounds()
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkPolyData
| C++: static vtkPolyData *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkPolyData
| C++: static vtkPolyData *GetData(vtkInformationVector *v, int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return what type of dataset this is.
|
| GetGhostLevel(...)
| GetGhostLevel(self) -> int
| C++: virtual int GetGhostLevel()
|
| Get the ghost level.
|
| GetLines(...)
| GetLines(self) -> vtkCellArray
| C++: vtkCellArray *GetLines()
|
| Get the cell array defining lines. If there are no lines, an
| empty array will be returned (convenience to simplify traversal).
|
| GetLinks(...)
| GetLinks(self) -> vtkAbstractCellLinks
| C++: virtual vtkAbstractCellLinks *GetLinks()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Get MTime which also considers its cell array MTime.
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Return the maximum cell size in this poly data.
|
| GetMaxSpatialDimension(...)
| GetMaxSpatialDimension(self) -> int
| C++: int GetMaxSpatialDimension() override;
|
| Get the maximum/minimum spatial dimensionality of the data which
| is the maximum/minimum dimension of all cells.
|
| GetMeshMTime(...)
| GetMeshMTime(self) -> int
| C++: vtkMTimeType GetMeshMTime() override;
|
| Return the mesh (geometry/topology) modification time. This time
| is different from the usual MTime which also takes into account
| the modification of data arrays. This function can be used to
| track the changes on the mesh separately from the data arrays
| (eg. static mesh over time with transient data).
|
| GetMinSpatialDimension(...)
| GetMinSpatialDimension(self) -> int
| C++: int GetMinSpatialDimension() override;
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| Standard vtkDataSet interface.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfLines(...)
| GetNumberOfLines(self) -> int
| C++: vtkIdType GetNumberOfLines()
|
| GetNumberOfPieces(...)
| GetNumberOfPieces(self) -> int
| C++: virtual int GetNumberOfPieces()
|
| GetNumberOfPolys(...)
| GetNumberOfPolys(self) -> int
| C++: vtkIdType GetNumberOfPolys()
|
| GetNumberOfStrips(...)
| GetNumberOfStrips(self) -> int
| C++: vtkIdType GetNumberOfStrips()
|
| GetNumberOfVerts(...)
| GetNumberOfVerts(self) -> int
| C++: vtkIdType GetNumberOfVerts()
|
| Return the number of primitives of a particular type held.
|
| GetPiece(...)
| GetPiece(self) -> int
| C++: virtual int GetPiece()
|
| Get the piece and the number of pieces. Similar to extent in 3D.
|
| GetPointCells(...)
| GetPointCells(self, ptId:int, cellIds:vtkIdList) -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
| override;
| GetPointCells(self, ptId:int, ncells:int, cells:[int, ...])
| -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdType &ncells,
| vtkIdType *&cells)
|
| Efficient method to obtain cells using a particular point. Make
| sure that routine BuildLinks() has been called.
|
| GetPolys(...)
| GetPolys(self) -> vtkCellArray
| C++: vtkCellArray *GetPolys()
|
| Get the cell array defining polygons. If there are no polygons,
| an empty array will be returned (convenience to simplify
| traversal).
|
| GetScalarFieldCriticalIndex(...)
| GetScalarFieldCriticalIndex(self, pointId:int,
| scalarField:vtkDataArray) -> int
| C++: int GetScalarFieldCriticalIndex(vtkIdType pointId,
| vtkDataArray *scalarField)
| GetScalarFieldCriticalIndex(self, pointId:int, fieldId:int) -> int
| C++: int GetScalarFieldCriticalIndex(vtkIdType pointId,
| int fieldId)
| GetScalarFieldCriticalIndex(self, pointId:int, fieldName:str)
| -> int
| C++: int GetScalarFieldCriticalIndex(vtkIdType pointId,
| const char *fieldName)
|
| GetStrips(...)
| GetStrips(self) -> vtkCellArray
| C++: vtkCellArray *GetStrips()
|
| Get the cell array defining triangle strips. If there are no
| triangle strips, an empty array will be returned (convenience to
| simplify traversal).
|
| GetVerts(...)
| GetVerts(self) -> vtkCellArray
| C++: vtkCellArray *GetVerts()
|
| Get the cell array defining vertices. If there are no vertices,
| an empty array will be returned (convenience to simplify
| traversal).
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Restore object to initial state. Release memory back to system.
|
| InsertNextCell(...)
| InsertNextCell(self, type:int, npts:int, pts:(int, ...)) -> int
| C++: vtkIdType InsertNextCell(int type, int npts,
| const vtkIdType pts[])
| InsertNextCell(self, type:int, pts:vtkIdList) -> int
| C++: vtkIdType InsertNextCell(int type, vtkIdList *pts)
|
| Insert a cell of type VTK_VERTEX, VTK_POLY_VERTEX, VTK_LINE,
| VTK_POLY_LINE, VTK_TRIANGLE, VTK_QUAD, VTK_POLYGON, or
| VTK_TRIANGLE_STRIP. Make sure that the PolyData::Allocate()
| function has been called first or that vertex, line, polygon, and
| triangle strip arrays have been supplied. Note: will also insert
| VTK_PIXEL, but converts it to VTK_QUAD.
|
| InsertNextLinkedCell(...)
| InsertNextLinkedCell(self, type:int, npts:int, pts:(int, ...))
| -> int
| C++: vtkIdType InsertNextLinkedCell(int type, int npts,
| const vtkIdType pts[])
|
| Add a new cell to the cell data structure (after cell pointers
| have been built). This method adds the cell and then updates the
| links from the points to the cells. (Memory is allocated as
| necessary.) Use this method only when the dataset is set as
| Editable.
|
| InsertNextLinkedPoint(...)
| InsertNextLinkedPoint(self, numLinks:int) -> int
| C++: vtkIdType InsertNextLinkedPoint(int numLinks)
| InsertNextLinkedPoint(self, x:[float, float, float], numLinks:int)
| -> int
| C++: vtkIdType InsertNextLinkedPoint(double x[3], int numLinks)
|
| Add a point to the cell data structure (after cell pointers have
| been built). This method adds the point and then allocates memory
| for the links to the cells. (To use this method, make sure
| points are available and BuildLinks() has been invoked.) Of the
| two methods below, one inserts a point coordinate and the other
| just makes room for cell links. Use this method only when the
| dataset is set as Editable.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsEdge(...)
| IsEdge(self, p1:int, p2:int) -> int
| C++: int IsEdge(vtkIdType p1, vtkIdType p2)
|
| Determine whether two points form an edge. If they do, return
| non-zero. By definition PolyVertex and PolyLine have no edges
| since 1-dimensional edges are only found on cells 2D and higher.
| Edges are defined as 1-D boundary entities to cells. Make sure
| BuildLinks() has been called first.
|
| IsPointUsedByCell(...)
| IsPointUsedByCell(self, ptId:int, cellId:int) -> int
| C++: int IsPointUsedByCell(vtkIdType ptId, vtkIdType cellId)
|
| Determine whether a point is used by a particular cell. If it is,
| return non-zero. Make sure BuildCells() has been called first.
|
| IsTriangle(...)
| IsTriangle(self, v1:int, v2:int, v3:int) -> int
| C++: int IsTriangle(int v1, int v2, int v3)
|
| Given three vertices, determine whether it's a triangle. Make
| sure BuildLinks() has been called first.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NeedToBuildCells(...)
| NeedToBuildCells(self) -> bool
| C++: bool NeedToBuildCells()
|
| Check if BuildCells is needed.
|
| NewInstance(...)
| NewInstance(self) -> vtkPolyData
| C++: vtkPolyData *NewInstance()
|
| RemoveCellReference(...)
| RemoveCellReference(self, cellId:int) -> None
| C++: void RemoveCellReference(vtkIdType cellId)
|
| Remove all references to cell in cell structure. This means the
| links from the cell's points to the cell are deleted. Memory is
| not reclaimed. Use the method ResizeCellList() to resize the link
| list from a point to its using cells. (This operator assumes
| BuildLinks() has been called.) Use this method only when the
| dataset is set as Editable.
|
| RemoveDeletedCells(...)
| RemoveDeletedCells(self) -> None
| C++: void RemoveDeletedCells()
|
| The cells marked by calls to DeleteCell are stored in the Cell
| Array VTK_EMPTY_CELL, but they still exist in the cell arrays.
| Calling RemoveDeletedCells will traverse the cell arrays and
| remove/compact the cell arrays as well as any cell data thus
| truly removing the cells from the polydata object. Use this
| method only when the dataset is set as Editable.
|
| RemoveGhostCells(...)
| RemoveGhostCells(self) -> None
| C++: void RemoveGhostCells()
|
| This method will remove any cell that is marked as ghost (has the
| vtkDataSetAttributes::DUPLICATECELL or the
| vtkDataSetAttributes::HIDDENCELL bit set). It does not remove
| unused points.
|
| RemoveReferenceToCell(...)
| RemoveReferenceToCell(self, ptId:int, cellId:int) -> None
| C++: void RemoveReferenceToCell(vtkIdType ptId, vtkIdType cellId)
|
| Remove a reference to a cell in a particular point's link list.
| You may also consider using RemoveCellReference() to remove the
| references from all the cell's points to the cell. This operator
| does not reallocate memory; use the operator ResizeCellList() to
| do this if necessary. Use this method only when the dataset is
| set as Editable.
|
| ReplaceCell(...)
| ReplaceCell(self, cellId:int, ids:vtkIdList) -> None
| C++: void ReplaceCell(vtkIdType cellId, vtkIdList *ids)
| ReplaceCell(self, cellId:int, npts:int, pts:(int, ...)) -> None
| C++: void ReplaceCell(vtkIdType cellId, int npts,
| const vtkIdType pts[])
|
| ReplaceCellPoint(...)
| ReplaceCellPoint(self, cellId:int, oldPtId:int, newPtId:int)
| -> None
| C++: void ReplaceCellPoint(vtkIdType cellId, vtkIdType oldPtId,
| vtkIdType newPtId)
| ReplaceCellPoint(self, cellId:int, oldPtId:int, newPtId:int,
| cellPointIds:vtkIdList) -> None
| C++: void ReplaceCellPoint(vtkIdType cellId, vtkIdType oldPtId,
| vtkIdType newPtId, vtkIdList *cellPointIds)
|
| Replace a point in the cell connectivity list with a different
| point. Use this method only when the dataset is set as Editable.
|
| The version with cellPointIds avoids allocating/deallocating a
| vtkIdList at each call internally.
|
| THIS METHOD IS THREAD SAFE IF BuildCells() IS FIRST CALLED FROM A
| SINGLE THREAD.
|
| ReplaceLinkedCell(...)
| ReplaceLinkedCell(self, cellId:int, npts:int, pts:(int, ...))
| -> None
| C++: void ReplaceLinkedCell(vtkIdType cellId, int npts,
| const vtkIdType pts[])
|
| Replace one cell with another in cell structure. This operator
| updates the connectivity list and the point's link list. It does
| not delete references to the old cell in the point's link list.
| Use the operator RemoveCellReference() to delete all references
| from points to (old) cell. You may also want to consider using
| the operator ResizeCellList() if the link list is changing size.
| Use this method only when the dataset is set as Editable.
|
| Reset(...)
| Reset(self) -> None
| C++: void Reset()
|
| Begin inserting data all over again. Memory is not freed but
| otherwise objects are returned to their initial state.
|
| ResizeCellList(...)
| ResizeCellList(self, ptId:int, size:int) -> None
| C++: void ResizeCellList(vtkIdType ptId, int size)
|
| Resize the list of cells using a particular point. (This operator
| assumes that BuildLinks() has been called.) Use this method only
| when the dataset is set as Editable.
|
| ReverseCell(...)
| ReverseCell(self, cellId:int) -> None
| C++: void ReverseCell(vtkIdType cellId)
|
| Reverse the order of point ids defining the cell. Use this method
| only when the dataset is set as Editable.
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkPolyData
| C++: static vtkPolyData *SafeDownCast(vtkObjectBase *o)
|
| SetLines(...)
| SetLines(self, l:vtkCellArray) -> None
| C++: void SetLines(vtkCellArray *l)
|
| Set the cell array defining lines.
|
| SetLinks(...)
| SetLinks(self, _arg:vtkAbstractCellLinks) -> None
| C++: virtual void SetLinks(vtkAbstractCellLinks *_arg)
|
| Set/Get the links that were created possibly without using
| BuildLinks.
|
| SetPolys(...)
| SetPolys(self, p:vtkCellArray) -> None
| C++: void SetPolys(vtkCellArray *p)
|
| Set the cell array defining polygons.
|
| SetStrips(...)
| SetStrips(self, s:vtkCellArray) -> None
| C++: void SetStrips(vtkCellArray *s)
|
| Set the cell array defining triangle strips.
|
| SetVerts(...)
| SetVerts(self, v:vtkCellArray) -> None
| C++: void SetVerts(vtkCellArray *v)
|
| Set the cell array defining vertices.
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: void Squeeze() override;
|
| Recover extra allocated memory when creating data whose initial
| size is unknown. Examples include using the InsertNextCell()
| method, or when using the CellArray::EstimateSize() method to
| create vertices, lines, polygons, or triangle strips.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkPolyData:
|
| __this__
| Pointer to the C++ object.
|
| data_object_type
| read-only, calls GetDataObjectType
|
| ghost_level
| read-only, calls GetGhostLevel
|
| links
| read-write, calls GetLinks/SetLinks
|
| m_time
| read-only, calls GetMTime
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| max_spatial_dimension
| read-only, calls GetMaxSpatialDimension
|
| mesh_m_time
| read-only, calls GetMeshMTime
|
| min_spatial_dimension
| read-only, calls GetMinSpatialDimension
|
| number_of_lines
| read-only, calls GetNumberOfLines
|
| number_of_pieces
| read-only, calls GetNumberOfPieces
|
| number_of_polys
| read-only, calls GetNumberOfPolys
|
| number_of_strips
| read-only, calls GetNumberOfStrips
|
| number_of_verts
| read-only, calls GetNumberOfVerts
|
| piece
| read-only, calls GetPiece
|
| polys
| read-write, calls GetPolys/SetPolys
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkPolyData:
|
| ERR_INCORRECT_FIELD = -3
|
| ERR_NON_MANIFOLD_STAR = -2
|
| ERR_NO_SUCH_FIELD = -4
|
| MAXIMUM = 2
|
| MINIMUM = 0
|
| REGULAR_POINT = -1
|
| SADDLE = 1
|
| __vtkname__ = 'vtkPolyData'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| BuildCellLocator(...)
| BuildCellLocator(self) -> None
| C++: void BuildCellLocator()
|
| Build the cell locator. In a multi-threaded environment, call
| this method in a single thread before using FindCell().
|
| BuildLocator(...)
| BuildLocator(self) -> None
| C++: void BuildLocator()
|
| BuildPointLocator(...)
| BuildPointLocator(self) -> None
| C++: void BuildPointLocator()
|
| Build the internal point locator . In a multi-threaded
| environment, call this method in a single thread before using
| FindCell() or FindPoint().
|
| ComputeBounds(...)
| ComputeBounds(self) -> None
| C++: void ComputeBounds() override;
|
| Compute the (X, Y, Z) bounds of the data.
|
| EditableOff(...)
| EditableOff(self) -> None
| C++: virtual void EditableOff()
|
| EditableOn(...)
| EditableOn(self) -> None
| C++: virtual void EditableOn()
|
| FindCell(...)
| FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int,
| tol2:float, subId:int, pcoords:[float, float, float],
| weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
| FindCell(self, x:[float, float, float], cell:vtkCell,
| gencell:vtkGenericCell, cellId:int, tol2:float, subId:int,
| pcoords:[float, float, float], weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkGenericCell *gencell, vtkIdType cellId, double tol2,
| int &subId, double pcoords[3], double *weights) override;
|
| Locate cell based on global coordinate x and tolerance squared.
| If cell and cellId is non-nullptr, then search starts from this
| cell and looks at immediate neighbors. Returns cellId >= 0 if
| inside, < 0 otherwise. The parametric coordinates are provided
| in pcoords[3]. The interpolation weights are returned in
| weights[]. (The number of weights is equal to the number of
| points in the found cell). Tolerance is used to control how close
| the point is to be considered "in" the cell. THIS METHOD IS NOT
| THREAD SAFE.
|
| FindPoint(...)
| FindPoint(self, x:[float, float, float]) -> int
| C++: vtkIdType FindPoint(double x[3]) override;
|
| GetCellLocator(...)
| GetCellLocator(self) -> vtkAbstractCellLocator
| C++: virtual vtkAbstractCellLocator *GetCellLocator()
|
| GetEditable(...)
| GetEditable(self) -> bool
| C++: virtual bool GetEditable()
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| See vtkDataSet for additional information.
|
| GetPoint(...)
| GetPoint(self, ptId:int, x:[float, float, float]) -> None
| C++: void GetPoint(vtkIdType ptId, double x[3]) override;
| GetPoint(self, ptId:int) -> (float, float, float)
| C++: double *GetPoint(vtkIdType ptId) override;
|
| Copy point coordinates into user provided array x[3] for
| specified point id. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetPointLocator(...)
| GetPointLocator(self) -> vtkAbstractPointLocator
| C++: virtual vtkAbstractPointLocator *GetPointLocator()
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints() override;
|
| If the subclass has (implicit/explicit) points, then return them.
| Otherwise, create a vtkPoints object and return that.
|
| DO NOT MODIFY THE RETURNED POINTS OBJECT.
|
| NewCellIterator(...)
| NewCellIterator(self) -> vtkCellIterator
| C++: vtkCellIterator *NewCellIterator() override;
|
| Return an iterator that traverses the cells in this data set.
|
| SetCellLocator(...)
| SetCellLocator(self, __a:vtkAbstractCellLocator) -> None
| C++: virtual void SetCellLocator(vtkAbstractCellLocator *)
|
| Set / get an instance of vtkAbstractCellLocator which may be used
| when a vtkCellLocatorStrategy is used during a FindCell()
| operation.
|
| SetEditable(...)
| SetEditable(self, _arg:bool) -> None
| C++: virtual void SetEditable(bool _arg)
|
| Specify whether this dataset is editable after creation. Meaning,
| once the points and cells are defined, can the dataset be
| incrementally modified. By default, this dataset is non-editable
| (i.e., "static") after construction. The reason for this is
| performance: cell links and locators can be built (and destroyed)
| much faster is it is known that the data is static (see
| vtkStaticCellLinks, vtkStaticPointLocator, vtkStaticCellLocator).
|
| SetPointLocator(...)
| SetPointLocator(self, __a:vtkAbstractPointLocator) -> None
| C++: virtual void SetPointLocator(vtkAbstractPointLocator *)
|
| Set / get an instance of vtkAbstractPointLocator which is used to
| support the FindPoint() and FindCell() methods. By default a
| vtkStaticPointLocator is used, unless the class is set as
| Editable, in which case a vtkPointLocator is used.
|
| SetPoints(...)
| SetPoints(self, __a:vtkPoints) -> None
| C++: virtual void SetPoints(vtkPoints *)
|
| Specify point array to define point coordinates.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Overwritten to handle the data/locator loop
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| cell_locator
| read-write, calls GetCellLocator/SetCellLocator
|
| editable
| read-write, calls GetEditable/SetEditable
|
| point_locator
| read-write, calls GetPointLocator/SetPointLocator
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| AllocateCellGhostArray(...)
| AllocateCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocateCellGhostArray()
|
| Allocate ghost array for cells.
|
| AllocatePointGhostArray(...)
| AllocatePointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocatePointGhostArray()
|
| Allocate ghost array for points.
|
| CheckAttributes(...)
| CheckAttributes(self) -> int
| C++: int CheckAttributes()
|
| This method checks to see if the cell and point attributes match
| the geometry. Many filters will crash if the number of tuples in
| an array is less than the number of points/cells. This method
| returns 1 if there is a mismatch, and 0 if everything is ok. It
| prints an error if an array is too short, and a warning if an
| array is too long.
|
| CopyAttributes(...)
| CopyAttributes(self, ds:vtkDataSet) -> None
| C++: virtual void CopyAttributes(vtkDataSet *ds)
|
| Copy the attributes associated with the specified dataset to this
| instance of vtkDataSet. THIS METHOD IS NOT THREAD SAFE.
|
| FindAndGetCell(...)
| FindAndGetCell(self, x:[float, float, float], cell:vtkCell,
| cellId:int, tol2:float, subId:int, pcoords:[float, float,
| float], weights:[float, ...]) -> vtkCell
| C++: virtual vtkCell *FindAndGetCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights)
|
| Locate the cell that contains a point and return the cell. Also
| returns the subcell id, parametric coordinates and weights for
| subsequent interpolation. This method combines the derived class
| methods int FindCell and vtkCell *GetCell. Derived classes may
| provide a more efficient implementation. See for example
| vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE.
|
| GenerateGhostArray(...)
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int])
| -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6])
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int],
| cellOnly:bool) -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6],
| bool cellOnly)
|
| Normally called by pipeline executives or algorithms only. This
| method computes the ghost arrays for a given dataset. The zeroExt
| argument specifies the extent of the region which ghost type = 0.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return a pointer to the geometry bounding box in the form
| (xmin,xmax, ymin,ymax, zmin,zmax). THIS METHOD IS NOT THREAD
| SAFE.
|
| GetCellData(...)
| GetCellData(self) -> vtkCellData
| C++: vtkCellData *GetCellData()
|
| Return a pointer to this dataset's cell data. THIS METHOD IS
| THREAD SAFE
|
| GetCellGhostArray(...)
| GetCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellGhostArray()
|
| Get the array that defines the ghost type of each cell. We cache
| the pointer to the array to save a lookup involving string
| comparisons
|
| GetCellNumberOfFaces(...)
| GetCellNumberOfFaces(self, cellId:int, cellType:int,
| cell:vtkGenericCell) -> int
| C++: virtual int GetCellNumberOfFaces(vtkIdType cellId,
| unsigned char &cellType, vtkGenericCell *cell)
|
| Get the number of faces of a cell.
|
| Most of the times extracting the number of faces requires only
| extracting the cell type. However, for some cell types, the
| number of faces is not constant. For example, a convex point set
| cell can have a different number of faces for each cell. That's
| why this method requires the cell id and the dataset.
|
| GetCellTypes(...)
| GetCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetCellTypes(vtkCellTypes *types)
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: double *GetCenter()
| GetCenter(self, center:[float, float, float]) -> None
| C++: void GetCenter(double center[3])
|
| Get the center of the bounding box. THIS METHOD IS NOT THREAD
| SAFE.
|
| GetDistinctCellTypes(...)
| GetDistinctCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetDistinctCellTypes(vtkCellTypes *types)
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset 5 triangles, 3 lines, and
| 100 hexahedra would result a list of three entries, corresponding
| to the types VTK_TRIANGLE, VTK_LINE, and VTK_HEXAHEDRON. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetGhostArray(int type) override;
|
| Returns the ghost array for the given type (point or cell). Takes
| advantage of the cache with the pointer to the array to save a
| string comparison.
|
| GetLength(...)
| GetLength(self) -> float
| C++: double GetLength()
|
| Return the length of the diagonal of the bounding box. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Return the squared length of the diagonal of the bounding box.
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| GetPointData(...)
| GetPointData(self) -> vtkPointData
| C++: vtkPointData *GetPointData()
|
| Return a pointer to this dataset's point data. THIS METHOD IS
| THREAD SAFE
|
| GetPointGhostArray(...)
| GetPointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetPointGhostArray()
|
| Gets the array that defines the ghost type of each point. We
| cache the pointer to the array to save a lookup involving string
| comparisons
|
| GetScalarRange(...)
| GetScalarRange(self, range:[float, float]) -> None
| C++: virtual void GetScalarRange(double range[2])
| GetScalarRange(self) -> (float, float)
| C++: double *GetScalarRange()
|
| Convenience method to get the range of the first component (and
| only the first component) of any scalars in the data set. If the
| data has both point data and cell data, it returns the (min/max)
| range of combined point and cell data. If there are no point or
| cell scalars the method will return (0,1). Note: It might be
| necessary to call Update to create or refresh the scalars before
| calling this method. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| HasAnyBlankCells(...)
| HasAnyBlankCells(self) -> bool
| C++: virtual bool HasAnyBlankCells()
|
| Returns 1 if there are any blanking cells 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyBlankPoints(...)
| HasAnyBlankPoints(self) -> bool
| C++: virtual bool HasAnyBlankPoints()
|
| Returns 1 if there are any blanking points 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyGhostCells(...)
| HasAnyGhostCells(self) -> bool
| C++: bool HasAnyGhostCells()
|
| Returns 1 if there are any ghost cells 0 otherwise.
|
| HasAnyGhostPoints(...)
| HasAnyGhostPoints(self) -> bool
| C++: bool HasAnyGhostPoints()
|
| Returns 1 if there are any ghost points 0 otherwise.
|
| SetCellOrderAndRationalWeights(...)
| SetCellOrderAndRationalWeights(self, cellId:int,
| cell:vtkGenericCell) -> None
| C++: void SetCellOrderAndRationalWeights(vtkIdType cellId,
| vtkGenericCell *cell)
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| cell_ghost_array
| read-only, calls GetCellGhostArray
|
| length2
| read-only, calls GetLength2
|
| point_ghost_array
| read-only, calls GetPointGhostArray
|
| scalar_range
| read-only, calls GetScalarRange
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| CELL_DATA_FIELD = 2
|
| DATA_OBJECT_FIELD = 0
|
| FieldDataType = <class 'vtkmodules.vtkCommonDataModel.vtkDataSet.Field...
|
| POINT_DATA_FIELD = 1
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: virtual void Crop(const int *updateExtent)
|
| This method crops the data object (if necessary) so that the
| extent matches the update extent.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: virtual int GetExtentType()
|
| The ExtentType will be left as VTK_PIECES_EXTENT for data objects
| such as vtkPolyData and vtkUnstructuredGrid. The ExtentType will
| be changed to VTK_3D_EXTENT for data objects with 3D structure
| such as vtkImageData (and its subclass vtkStructuredPoints),
| vtkRectilinearGrid, and vtkStructuredGrid. The default is the
| have an extent in pieces, with only one piece (no streaming
| possible).
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| extent_type
| read-only, calls GetExtentType
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class StructuredGrid(PointGrid, pyvista.core.filters.structured_grid.StructuredGridFilters, vtkmodules.vtkCommonDataModel.vtkStructuredGrid)
| StructuredGrid(*args, **kwargs) -> '_T'
|
| Dataset used for topologically regular arrays of data.
|
| Can be initialized in one of the following several ways:
|
| * Create empty grid.
| * Initialize from a filename.
| * Initialize from a :vtk:`vtkStructuredGrid` object.
| * Initialize directly from one or more :class:`numpy.ndarray`. See the
| example or the documentation of ``uinput``.
|
| Parameters
| ----------
| uinput : str, Path, :vtk:`vtkStructuredGrid`, numpy.ndarray, optional
| Filename, dataset, or array to initialize the structured grid from. If
| a filename is passed, pyvista will attempt to load it as a
| :class:`StructuredGrid`. If passed a :vtk:`vtkStructuredGrid`, it will
| be wrapped as a deep copy.
|
| If a :class:`numpy.ndarray` is provided and ``y`` and ``z`` are empty,
| this array will define the points of this :class:`StructuredGrid`.
| Set the dimensions with :attr:`StructuredGrid.dimensions`.
|
| Otherwise, this parameter will be loaded as the ``x`` points, and ``y``
| and ``z`` points must be set. The shape of this array defines the shape
| of the structured data and the shape should be ``(dimx, dimy,
| dimz)``. Missing trailing dimensions are assumed to be ``1``.
|
| y : numpy.ndarray, optional
| Coordinates of the points in y direction. If this is passed, ``uinput``
| must be a :class:`numpy.ndarray` and match the shape of ``y``.
|
| z : numpy.ndarray, optional
| Coordinates of the points in z direction. If this is passed, ``uinput``
| and ``y`` must be a :class:`numpy.ndarray` and match the shape of ``z``.
|
| deep : bool, default: False
| Whether to deep copy a StructuredGrid object.
| Default is ``False``. Keyword only.
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| **kwargs : dict, optional
| Additional keyword arguments passed when reading from a file or loading
| from arrays.
|
| See Also
| --------
| :ref:`create_structured_surface_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import vtk
| >>> import numpy as np
|
| Create an empty structured grid.
|
| >>> grid = pv.StructuredGrid()
|
| Initialize from a :vtk:`vtkStructuredGrid` object
|
| >>> vtkgrid = vtk.vtkStructuredGrid()
| >>> grid = pv.StructuredGrid(vtkgrid)
|
| Create from NumPy arrays using :func:`numpy.meshgrid`.
|
| >>> xrng = np.linspace(-5, 5, 10)
| >>> yrng = np.linspace(-8, 8, 4)
| >>> zrng = np.linspace(-7, 4, 20)
| >>> x, y, z = np.meshgrid(xrng, yrng, zrng, indexing='ij')
| >>> grid = pv.StructuredGrid(x, y, z)
| >>> grid
| StructuredGrid (...)
| N Cells: 513
| N Points: 800
| X Bounds: -5.000e+00, 5.000e+00
| Y Bounds: -8.000e+00, 8.000e+00
| Z Bounds: -7.000e+00, 4.000e+00
| Dimensions: 10, 4, 20
| N Arrays: 0
|
| Note how the grid dimensions match the shape of the input arrays.
|
| >>> (xrng.size, yrng.size, zrng.size)
| (10, 4, 20)
|
| Method resolution order:
| StructuredGrid
| PointGrid
| _PointSet
| pyvista.core.dataset.DataSet
| pyvista.core.filters.structured_grid.StructuredGridFilters
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkStructuredGrid
| vtkmodules.vtkCommonDataModel.vtkPointSet
| vtkmodules.vtkCommonDataModel.vtkDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __getitem__(self, key)
| Slice subsets of the StructuredGrid, or extract an array field.
|
| __init__(self, uinput=None, y=None, z=None, *args, deep: 'bool' = False, validate: 'bool | _NestedMeshValidationFields' = False, **kwargs) -> 'None'
| Initialize the structured grid.
|
| __repr__(self)
| Return the standard representation.
|
| __str__(self)
| Return the standard str representation.
|
| cast_to_explicit_structured_grid(self) -> 'ExplicitStructuredGrid'
| Cast to an explicit structured grid.
|
| Returns
| -------
| pyvista.ExplicitStructuredGrid
| An explicit structured grid.
|
| Raises
| ------
| TypeError
| If the structured grid is not 3D (i.e., any dimension is 1).
|
| hide_cells(self, ind, inplace: 'bool' = False) -> 'Self'
| Hide cells without deleting them.
|
| Hides cells by setting the ghost_cells array to ``HIDDEN_CELL``.
|
| Parameters
| ----------
| ind : sequence[int]
| List or array of cell indices to be hidden. The array can
| also be a boolean array of the same size as the number of
| cells.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.StructuredGrid
| Structured grid with hidden cells.
|
| Examples
| --------
| Hide part of the middle of a structured surface.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> x = np.arange(-10, 10, 0.25)
| >>> y = np.arange(-10, 10, 0.25)
| >>> z = 0
| >>> x, y, z = np.meshgrid(x, y, z)
| >>> grid = pv.StructuredGrid(x, y, z)
| >>> grid = grid.hide_cells(range(79 * 30, 79 * 50))
| >>> grid.plot(color=True, show_edges=True)
|
| hide_points(self, ind: 'VectorLike[bool] | VectorLike[int]') -> 'None'
| Hide points without deleting them.
|
| Hides points by setting the ghost_points array to ``HIDDEN_CELL``.
|
| Parameters
| ----------
| ind : VectorLike[bool] | VectorLike[int]
| Vector of point indices to be hidden. The vector can also be a
| boolean array of the same size as the number of points.
|
| Examples
| --------
| Hide part of the middle of a structured surface.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> x = np.arange(-10, 10, 0.25)
| >>> y = np.arange(-10, 10, 0.25)
| >>> z = 0
| >>> x, y, z = np.meshgrid(x, y, z)
| >>> grid = pv.StructuredGrid(x, y, z)
| >>> grid.hide_points(range(80 * 30, 80 * 50))
| >>> grid.plot(color=True, show_edges=True)
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| points_matrix
| Points as a 4-D matrix, with x/y/z along the last dimension.
|
| x
| Return the X coordinates of all points.
|
| Returns
| -------
| numpy.ndarray
| Numpy array of all X coordinates.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> xrng = np.arange(-10, 10, 1, dtype=np.float32)
| >>> yrng = np.arange(-10, 10, 2, dtype=np.float32)
| >>> zrng = np.arange(-10, 10, 5, dtype=np.float32)
| >>> x, y, z = np.meshgrid(xrng, yrng, zrng, indexing='ij')
| >>> grid = pv.StructuredGrid(x, y, z)
| >>> grid.x.shape
| (20, 10, 4)
|
| y
| Return the Y coordinates of all points.
|
| z
| Return the Z coordinates of all points.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| dimensions
| Return a length 3 tuple of the grid's dimensions.
|
| Returns
| -------
| tuple
| Grid dimensions.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> xrng = np.arange(-10, 10, 1, dtype=np.float32)
| >>> yrng = np.arange(-10, 10, 2, dtype=np.float32)
| >>> zrng = np.arange(-10, 10, 5, dtype=np.float32)
| >>> x, y, z = np.meshgrid(xrng, yrng, zrng, indexing='ij')
| >>> grid = pv.StructuredGrid(x, y, z)
| >>> grid.dimensions
| (20, 10, 4)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[StructuredGrid...
|
| ----------------------------------------------------------------------
| Methods inherited from PointGrid:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| plot_curvature(self: 'Self', curv_type='mean', **kwargs)
| Plot the curvature of the external surface of the grid.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| One of the following strings indicating curvature types.
| - ``'mean'``
| - ``'gaussian'``
| - ``'maximum'``
| - ``'minimum'``
|
| **kwargs : dict, optional
| Optional keyword arguments. See :func:`pyvista.plot`.
|
| Returns
| -------
| list
| Camera position, focal point, and view up. Returned when
| ``return_cpos`` is ``True``.
|
| ----------------------------------------------------------------------
| Methods inherited from _PointSet:
|
| center_of_mass(self, scalars_weight: 'bool' = False) -> 'NumpyArray[float]'
| Return the coordinates for the center of mass of the mesh.
|
| Parameters
| ----------
| scalars_weight : bool, default: False
| Flag for using the mesh scalars as weights.
|
| Returns
| -------
| numpy.ndarray
| Coordinates for the center of mass.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 1, 1))
| >>> mesh.center_of_mass()
| array([1., 1., 1.])
|
| points_to_double(self) -> 'Self'
| Convert the points datatype to double precision.
|
| Returns
| -------
| pyvista.PointSet
| Pointset with points in double precision.
|
| Notes
| -----
| This operates in place.
|
| Examples
| --------
| Create a mesh that has points of the type ``float32`` and
| convert the points to ``float64``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.points.dtype
| dtype('float32')
| >>> _ = mesh.points_to_double()
| >>> mesh.points.dtype
| dtype('float64')
|
| remove_cells(self, ind: 'VectorLike[bool] | VectorLike[int]', inplace: 'bool' = False) -> '_PointSet'
| Remove cells.
|
| Parameters
| ----------
| ind : VectorLike[int] | VectorLike[bool]
| Cell indices to be removed. The array can also be a
| boolean array of the same size as the number of cells.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| Returns
| -------
| pyvista.DataSet
| Same type as the input, but with the specified cells
| removed.
|
| See Also
| --------
| :ref:`ghost_cells_example`
|
| Examples
| --------
| Remove 20 cells from an unstructured grid.
|
| >>> from pyvista import examples
| >>> import pyvista as pv
| >>> hex_mesh = pv.read(examples.hexbeamfile)
| >>> removed = hex_mesh.remove_cells(range(10, 20))
| >>> removed.plot(color='lightblue', show_edges=True, line_width=3)
|
| shallow_copy(self, to_copy: 'DataSet') -> 'None'
| Create a shallow copy from a different dataset into this one.
|
| This method mutates this dataset and returns ``None``.
|
| Parameters
| ----------
| to_copy : pyvista.DataSet
| Data object to perform the shallow copy from.
|
| translate(self: 'Self', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False)
| Translate the mesh.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats of cartesian values to translate the mesh with.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed. This is
| only valid when not updating in place.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PointSet
| Translated pointset.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=True)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.structured_grid.StructuredGridFilters:
|
| concatenate(self, other, axis, tolerance=0.0)
| Concatenate a structured grid to this grid.
|
| Joins structured grids into a single structured grid. Grids
| must be of compatible dimension, and must be coincident along
| the seam. Grids must have the same point and cell data. Field
| data is ignored.
|
| Parameters
| ----------
| other : pyvista.StructuredGrid
| Structured grid to concatenate.
|
| axis : int
| Axis along which to concatenate.
|
| tolerance : float, default: 0.0
| Tolerance for point coincidence along joining seam.
|
| Returns
| -------
| pyvista.StructuredGrid
| Concatenated grid.
|
| Examples
| --------
| Split a grid in half and join them.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_structured()
| >>> voi_1 = grid.extract_subset([0, 80, 0, 40, 0, 1], boundary=True)
| >>> voi_2 = grid.extract_subset([0, 80, 40, 80, 0, 1], boundary=True)
| >>> joined = voi_1.concatenate(voi_2, axis=1)
| >>> f'{grid.dimensions} same as {joined.dimensions}'
| '(80, 80, 1) same as (80, 80, 1)'
|
| extract_subset(self, voi, rate=(1, 1, 1), boundary: 'bool' = False)
| Select piece (e.g., volume of interest).
|
| To use this filter set the VOI ivar which are i-j-k min/max
| indices that specify a rectangular region in the data. (Note
| that these are 0-offset.) You can also specify a sampling rate
| to subsample the data.
|
| Typical applications of this filter are to extract a slice
| from a volume for image processing, subsampling large volumes
| to reduce data size, or extracting regions of a volume with
| interesting data.
|
| Parameters
| ----------
| voi : sequence[int]
| Length 6 iterable of ints: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| These bounds specify the volume of interest in i-j-k min/max
| indices.
|
| rate : sequence[int], default: (1, 1, 1)
| Length 3 iterable of ints: ``(xrate, yrate, zrate)``.
|
| boundary : bool, default: False
| Control whether to enforce that the "boundary" of the grid
| is output in the subsampling process. (This only has
| effect when the rate in any direction is not equal to
| 1). When this is on, the subsampling will always include
| the boundary of the grid even if the sample rate is
| not an even multiple of the grid dimensions.
|
| Returns
| -------
| pyvista.StructuredGrid
| StructuredGrid with extracted subset.
|
| Examples
| --------
| Split a grid in half.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_structured()
| >>> voi_1 = grid.extract_subset([0, 80, 0, 40, 0, 1], boundary=True)
| >>> voi_2 = grid.extract_subset([0, 80, 40, 80, 0, 1], boundary=True)
|
| For fun, add the two grids back together and show they are
| identical to the original grid.
|
| >>> joined = voi_1.concatenate(voi_2, axis=1)
| >>> assert np.allclose(grid.points, joined.points)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkStructuredGrid:
|
| BlankCell(...)
| BlankCell(self, ptId:int) -> None
| C++: void BlankCell(vtkIdType ptId)
|
| Methods for supporting blanking of cells. Blanking turns on or
| off cells in the structured grid, and hence the points connected
| to them. These methods should be called only after the dimensions
| of the grid are set.
|
| BlankPoint(...)
| BlankPoint(self, ptId:int) -> None
| C++: void BlankPoint(vtkIdType ptId)
|
| Methods for supporting blanking of cells. Blanking turns on or
| off points in the structured grid, and hence the cells connected
| to them. These methods should be called only after the dimensions
| of the grid are set.
|
| CopyStructure(...)
| CopyStructure(self, ds:vtkDataSet) -> None
| C++: void CopyStructure(vtkDataSet *ds) override;
|
| Copy the geometric and topological structure of an input poly
| data object.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: void Crop(const int *updateExtent) override;
|
| Reallocates and copies to set the Extent to the UpdateExtent.
| This is used internally when the exact extent is requested, and
| the source generated more than the update extent.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| The goal of the method is to copy the complete data from src into
| this object. The implementation is delegated to the differenent
| subclasses. If you want to copy the data up to the array pointers
| only, @see ShallowCopy.
|
| This method deep copy the field data and copy the internal
| structure.
|
| ExtendedNew(...)
| ExtendedNew() -> vtkStructuredGrid
| C++: static vtkStructuredGrid *ExtendedNew()
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated. The
| memory size returned is guaranteed to be greater than or equal to
| the memory required to represent the data (e.g., extra space in
| arrays, etc. are not included in the return value). THIS METHOD
| IS THREAD SAFE.
|
| GetCell(...)
| GetCell(self, cellId:int) -> vtkCell
| C++: vtkCell *GetCell(vtkIdType cellId) override;
| GetCell(self, i:int, j:int, k:int) -> vtkCell
| C++: vtkCell *GetCell(int i, int j, int k) override;
| GetCell(self, cellId:int, cell:vtkGenericCell) -> None
| C++: void GetCell(vtkIdType cellId, vtkGenericCell *cell)
| override;
|
| This method always return a `vtkEmptyCell`, as there is no cell
| in a `vtkPointSet`.
|
| GetCellBounds(...)
| GetCellBounds(self, cellId:int, bounds:[float, float, float,
| float, float, float]) -> None
| C++: void GetCellBounds(vtkIdType cellId, double bounds[6])
| override;
|
| Get the bounds of the cell with cellId such that: 0 <= cellId <
| NumberOfCells. A subclass may be able to determine the bounds of
| cell without using an expensive GetCell() method. A default
| implementation is provided that actually uses a GetCell() call.
| This is to ensure the method is available to all datasets.
| Subclasses should override this method to provide an efficient
| implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetCellDims(...)
| GetCellDims(self, cellDims:[int, int, int]) -> None
| C++: void GetCellDims(int cellDims[3])
|
| Given the node dimensions of this grid instance, this method
| computes the node dimensions. The value in each dimension can
| will have a lowest value of "1" such that computing the total
| number of cells can be achieved by simply by
| cellDims[0]*cellDims[1]*cellDims[2].
|
| GetCellNeighbors(...)
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds) override;
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList, seedLoc:[int, ...]) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds, int *seedLoc)
|
| Topological inquiry to get all cells using list of points
| exclusive of cell specified (e.g., cellId). Note that the list
| consists of only cells that use ALL the points provided. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetCellPoints(...)
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...),
| ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts, vtkIdList *ptIds) override;
| GetCellPoints(self, cellId:int, ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
| override;
|
| Topological inquiry to get points defining cell.
|
| This function MAY use ptIds, which is an object that is created
| by each thread, to guarantee thread safety.
|
| @warning Subsequent calls to this method may invalidate previous
| call
| results.
|
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetCellSize(...)
| GetCellSize(self, cellId:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType cellId) override;
|
| This method always returns 1, as all cells are point in a pure
| `vtkPointSet`.
|
| GetCellType(...)
| GetCellType(self, cellId:int) -> int
| C++: int GetCellType(vtkIdType cellId) override;
|
| This method always returns `VTK_EMPTY_CELL`, as there is no cell
| in a `vtkPointSet`.
|
| GetCellTypes(...)
| GetCellTypes(self) -> vtkConstantArray_IhE
| C++: vtkConstantArray<unsigned char> *GetCellTypes()
| GetCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetCellTypes(vtkCellTypes *types)
|
| GetCellTypesArray(...)
| GetCellTypesArray(self) -> vtkConstantArray_IiE
| C++: vtkConstantArray<int> *GetCellTypesArray()
|
| GetCells(...)
| GetCells(self) -> vtkStructuredCellArray
| C++: vtkStructuredCellArray *GetCells()
|
| Return the structured grid connectivity array.
|
| NOTE: the returned object should not be modified.
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkStructuredGrid
| C++: static vtkStructuredGrid *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkStructuredGrid
| C++: static vtkStructuredGrid *GetData(vtkInformationVector *v,
| int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataDescription(...)
| GetDataDescription(self) -> int
| C++: virtual int GetDataDescription()
|
| Get the data description of the structured grid.
|
| GetDataDimension(...)
| GetDataDimension(self) -> int
| C++: int GetDataDimension()
|
| Return the dimensionality of the data.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Return what type of dataset this is.
|
| GetDimensions(...)
| GetDimensions(self, dims:[int, int, int]) -> None
| C++: virtual void GetDimensions(int dims[3])
|
| Get dimensions of this structured grid based on its extent.
|
| GetExtent(...)
| GetExtent(self) -> (int, int, int, int, int, int)
| C++: virtual int *GetExtent()
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: int GetExtentType() override;
|
| The extent type is a 3D extent
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Convenience method returns largest cell size in dataset. This is
| generally used to allocate memory for supporting data structures.
| THIS METHOD IS THREAD SAFE
|
| GetMaxSpatialDimension(...)
| GetMaxSpatialDimension(self) -> int
| C++: int GetMaxSpatialDimension() override;
|
| Get the maximum/minimum spatial dimensionality of the data which
| is the maximum/minimum dimension of all cells.
|
| @warning This method MUST be overridden for performance reasons.
| Default implementation is very inefficient.
|
| GetMinSpatialDimension(...)
| GetMinSpatialDimension(self) -> int
| C++: int GetMinSpatialDimension() override;
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| Standard vtkDataSet API methods. See vtkDataSet for more
| information.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| See vtkDataSet for additional information.
|
| GetPoint(...)
| GetPoint(self, ptId:int) -> (float, float, float)
| C++: double *GetPoint(vtkIdType ptId) override;
| GetPoint(self, ptId:int, p:[float, float, float]) -> None
| C++: void GetPoint(vtkIdType ptId, double p[3]) override;
| GetPoint(self, i:int, j:int, k:int, p:[float, float, float],
| adjustForExtent:bool=True) -> None
| C++: void GetPoint(int i, int j, int k, double p[3],
| bool adjustForExtent=true)
|
| See vtkDataSet for additional information. WARNING: Just don't
| use this error-prone method, the returned pointer and its values
| are only valid as long as another method invocation is not
| performed. Prefer GetPoint() with the return value in argument.
|
| GetPointCells(...)
| GetPointCells(self, ptId:int, cellIds:vtkIdList) -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
| override;
|
| Topological inquiry to get cells using point. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| HasAnyBlankCells(...)
| HasAnyBlankCells(self) -> bool
| C++: bool HasAnyBlankCells() override;
|
| Returns 1 if there is any visibility constraint on the cells, 0
| otherwise.
|
| HasAnyBlankPoints(...)
| HasAnyBlankPoints(self) -> bool
| C++: bool HasAnyBlankPoints() override;
|
| Returns 1 if there is any visibility constraint on the points, 0
| otherwise.
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Restore object to initial state. Release memory back to system.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsCellVisible(...)
| IsCellVisible(self, cellId:int) -> int
| C++: unsigned char IsCellVisible(vtkIdType cellId)
|
| Return non-zero value if specified point is visible. These
| methods should be called only after the dimensions of the grid
| are set.
|
| IsPointVisible(...)
| IsPointVisible(self, ptId:int) -> int
| C++: unsigned char IsPointVisible(vtkIdType ptId)
|
| Return non-zero value if specified point is visible. These
| methods should be called only after the dimensions of the grid
| are set.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewInstance(...)
| NewInstance(self) -> vtkStructuredGrid
| C++: vtkStructuredGrid *NewInstance()
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkStructuredGrid
| C++: static vtkStructuredGrid *SafeDownCast(vtkObjectBase *o)
|
| SetDimensions(...)
| SetDimensions(self, i:int, j:int, k:int) -> None
| C++: void SetDimensions(int i, int j, int k)
| SetDimensions(self, dims:(int, int, int)) -> None
| C++: void SetDimensions(const int dims[3])
|
| Sets the extent to be 0 to i-1, 0 to j-1, and 0 to k-1.
|
| SetExtent(...)
| SetExtent(self, extent:[int, int, int, int, int, int]) -> None
| C++: void SetExtent(int extent[6])
| SetExtent(self, xMin:int, xMax:int, yMin:int, yMax:int, zMin:int,
| zMax:int) -> None
| C++: void SetExtent(int xMin, int xMax, int yMin, int yMax,
| int zMin, int zMax)
|
| Different ways to set the extent of the data array. The extent
| should be set before the "Scalars" are set or allocated. The
| Extent is stored in the order (X, Y, Z).
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| UnBlankCell(...)
| UnBlankCell(self, ptId:int) -> None
| C++: void UnBlankCell(vtkIdType ptId)
|
| UnBlankPoint(...)
| UnBlankPoint(self, ptId:int) -> None
| C++: void UnBlankPoint(vtkIdType ptId)
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkStructuredGrid:
|
| __this__
| Pointer to the C++ object.
|
| cell_types
| read-only, calls GetCellTypes
|
| cell_types_array
| read-only, calls GetCellTypesArray
|
| cells
| read-only, calls GetCells
|
| data_description
| read-only, calls GetDataDescription
|
| data_dimension
| read-only, calls GetDataDimension
|
| data_object_type
| read-only, calls GetDataObjectType
|
| extent
| read-write, calls GetExtent/SetExtent
|
| extent_type
| read-only, calls GetExtentType
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| max_spatial_dimension
| read-only, calls GetMaxSpatialDimension
|
| min_spatial_dimension
| read-only, calls GetMinSpatialDimension
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkStructuredGrid:
|
| __vtkname__ = 'vtkStructuredGrid'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| BuildCellLocator(...)
| BuildCellLocator(self) -> None
| C++: void BuildCellLocator()
|
| Build the cell locator. In a multi-threaded environment, call
| this method in a single thread before using FindCell().
|
| BuildLocator(...)
| BuildLocator(self) -> None
| C++: void BuildLocator()
|
| BuildPointLocator(...)
| BuildPointLocator(self) -> None
| C++: void BuildPointLocator()
|
| Build the internal point locator . In a multi-threaded
| environment, call this method in a single thread before using
| FindCell() or FindPoint().
|
| ComputeBounds(...)
| ComputeBounds(self) -> None
| C++: void ComputeBounds() override;
|
| Compute the (X, Y, Z) bounds of the data.
|
| EditableOff(...)
| EditableOff(self) -> None
| C++: virtual void EditableOff()
|
| EditableOn(...)
| EditableOn(self) -> None
| C++: virtual void EditableOn()
|
| FindCell(...)
| FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int,
| tol2:float, subId:int, pcoords:[float, float, float],
| weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
| FindCell(self, x:[float, float, float], cell:vtkCell,
| gencell:vtkGenericCell, cellId:int, tol2:float, subId:int,
| pcoords:[float, float, float], weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkGenericCell *gencell, vtkIdType cellId, double tol2,
| int &subId, double pcoords[3], double *weights) override;
|
| Locate cell based on global coordinate x and tolerance squared.
| If cell and cellId is non-nullptr, then search starts from this
| cell and looks at immediate neighbors. Returns cellId >= 0 if
| inside, < 0 otherwise. The parametric coordinates are provided
| in pcoords[3]. The interpolation weights are returned in
| weights[]. (The number of weights is equal to the number of
| points in the found cell). Tolerance is used to control how close
| the point is to be considered "in" the cell. THIS METHOD IS NOT
| THREAD SAFE.
|
| FindPoint(...)
| FindPoint(self, x:[float, float, float]) -> int
| C++: vtkIdType FindPoint(double x[3]) override;
|
| GetCellLocator(...)
| GetCellLocator(self) -> vtkAbstractCellLocator
| C++: virtual vtkAbstractCellLocator *GetCellLocator()
|
| GetEditable(...)
| GetEditable(self) -> bool
| C++: virtual bool GetEditable()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Get MTime which also considers its vtkPoints MTime.
|
| GetPointLocator(...)
| GetPointLocator(self) -> vtkAbstractPointLocator
| C++: virtual vtkAbstractPointLocator *GetPointLocator()
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints() override;
|
| If the subclass has (implicit/explicit) points, then return them.
| Otherwise, create a vtkPoints object and return that.
|
| DO NOT MODIFY THE RETURNED POINTS OBJECT.
|
| NewCellIterator(...)
| NewCellIterator(self) -> vtkCellIterator
| C++: vtkCellIterator *NewCellIterator() override;
|
| Return an iterator that traverses the cells in this data set.
|
| SetCellLocator(...)
| SetCellLocator(self, __a:vtkAbstractCellLocator) -> None
| C++: virtual void SetCellLocator(vtkAbstractCellLocator *)
|
| Set / get an instance of vtkAbstractCellLocator which may be used
| when a vtkCellLocatorStrategy is used during a FindCell()
| operation.
|
| SetEditable(...)
| SetEditable(self, _arg:bool) -> None
| C++: virtual void SetEditable(bool _arg)
|
| Specify whether this dataset is editable after creation. Meaning,
| once the points and cells are defined, can the dataset be
| incrementally modified. By default, this dataset is non-editable
| (i.e., "static") after construction. The reason for this is
| performance: cell links and locators can be built (and destroyed)
| much faster is it is known that the data is static (see
| vtkStaticCellLinks, vtkStaticPointLocator, vtkStaticCellLocator).
|
| SetPointLocator(...)
| SetPointLocator(self, __a:vtkAbstractPointLocator) -> None
| C++: virtual void SetPointLocator(vtkAbstractPointLocator *)
|
| Set / get an instance of vtkAbstractPointLocator which is used to
| support the FindPoint() and FindCell() methods. By default a
| vtkStaticPointLocator is used, unless the class is set as
| Editable, in which case a vtkPointLocator is used.
|
| SetPoints(...)
| SetPoints(self, __a:vtkPoints) -> None
| C++: virtual void SetPoints(vtkPoints *)
|
| Specify point array to define point coordinates.
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: void Squeeze() override;
|
| Reclaim any unused memory.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Overwritten to handle the data/locator loop
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| cell_locator
| read-write, calls GetCellLocator/SetCellLocator
|
| editable
| read-write, calls GetEditable/SetEditable
|
| m_time
| read-only, calls GetMTime
|
| point_locator
| read-write, calls GetPointLocator/SetPointLocator
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| AllocateCellGhostArray(...)
| AllocateCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocateCellGhostArray()
|
| Allocate ghost array for cells.
|
| AllocatePointGhostArray(...)
| AllocatePointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocatePointGhostArray()
|
| Allocate ghost array for points.
|
| CheckAttributes(...)
| CheckAttributes(self) -> int
| C++: int CheckAttributes()
|
| This method checks to see if the cell and point attributes match
| the geometry. Many filters will crash if the number of tuples in
| an array is less than the number of points/cells. This method
| returns 1 if there is a mismatch, and 0 if everything is ok. It
| prints an error if an array is too short, and a warning if an
| array is too long.
|
| CopyAttributes(...)
| CopyAttributes(self, ds:vtkDataSet) -> None
| C++: virtual void CopyAttributes(vtkDataSet *ds)
|
| Copy the attributes associated with the specified dataset to this
| instance of vtkDataSet. THIS METHOD IS NOT THREAD SAFE.
|
| FindAndGetCell(...)
| FindAndGetCell(self, x:[float, float, float], cell:vtkCell,
| cellId:int, tol2:float, subId:int, pcoords:[float, float,
| float], weights:[float, ...]) -> vtkCell
| C++: virtual vtkCell *FindAndGetCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights)
|
| Locate the cell that contains a point and return the cell. Also
| returns the subcell id, parametric coordinates and weights for
| subsequent interpolation. This method combines the derived class
| methods int FindCell and vtkCell *GetCell. Derived classes may
| provide a more efficient implementation. See for example
| vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE.
|
| GenerateGhostArray(...)
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int])
| -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6])
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int],
| cellOnly:bool) -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6],
| bool cellOnly)
|
| Normally called by pipeline executives or algorithms only. This
| method computes the ghost arrays for a given dataset. The zeroExt
| argument specifies the extent of the region which ghost type = 0.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return a pointer to the geometry bounding box in the form
| (xmin,xmax, ymin,ymax, zmin,zmax). THIS METHOD IS NOT THREAD
| SAFE.
|
| GetCellData(...)
| GetCellData(self) -> vtkCellData
| C++: vtkCellData *GetCellData()
|
| Return a pointer to this dataset's cell data. THIS METHOD IS
| THREAD SAFE
|
| GetCellGhostArray(...)
| GetCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellGhostArray()
|
| Get the array that defines the ghost type of each cell. We cache
| the pointer to the array to save a lookup involving string
| comparisons
|
| GetCellNumberOfFaces(...)
| GetCellNumberOfFaces(self, cellId:int, cellType:int,
| cell:vtkGenericCell) -> int
| C++: virtual int GetCellNumberOfFaces(vtkIdType cellId,
| unsigned char &cellType, vtkGenericCell *cell)
|
| Get the number of faces of a cell.
|
| Most of the times extracting the number of faces requires only
| extracting the cell type. However, for some cell types, the
| number of faces is not constant. For example, a convex point set
| cell can have a different number of faces for each cell. That's
| why this method requires the cell id and the dataset.
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: double *GetCenter()
| GetCenter(self, center:[float, float, float]) -> None
| C++: void GetCenter(double center[3])
|
| Get the center of the bounding box. THIS METHOD IS NOT THREAD
| SAFE.
|
| GetDistinctCellTypes(...)
| GetDistinctCellTypes(self, types:vtkCellTypes) -> None
| C++: virtual void GetDistinctCellTypes(vtkCellTypes *types)
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset 5 triangles, 3 lines, and
| 100 hexahedra would result a list of three entries, corresponding
| to the types VTK_TRIANGLE, VTK_LINE, and VTK_HEXAHEDRON. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetGhostArray(int type) override;
|
| Returns the ghost array for the given type (point or cell). Takes
| advantage of the cache with the pointer to the array to save a
| string comparison.
|
| GetLength(...)
| GetLength(self) -> float
| C++: double GetLength()
|
| Return the length of the diagonal of the bounding box. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Return the squared length of the diagonal of the bounding box.
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetMeshMTime(...)
| GetMeshMTime(self) -> int
| C++: virtual vtkMTimeType GetMeshMTime()
|
| Abstract method which return the mesh (geometry/topology)
| modification time. This time is different from the usual MTime
| which also takes into account the modification of data arrays.
| This function can be used to track the changes on the mesh
| separately from the data arrays (eg. static mesh over time with
| transient data). The default implementation returns the MTime. It
| is up to subclasses to provide a better approach.
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| GetPointData(...)
| GetPointData(self) -> vtkPointData
| C++: vtkPointData *GetPointData()
|
| Return a pointer to this dataset's point data. THIS METHOD IS
| THREAD SAFE
|
| GetPointGhostArray(...)
| GetPointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetPointGhostArray()
|
| Gets the array that defines the ghost type of each point. We
| cache the pointer to the array to save a lookup involving string
| comparisons
|
| GetScalarRange(...)
| GetScalarRange(self, range:[float, float]) -> None
| C++: virtual void GetScalarRange(double range[2])
| GetScalarRange(self) -> (float, float)
| C++: double *GetScalarRange()
|
| Convenience method to get the range of the first component (and
| only the first component) of any scalars in the data set. If the
| data has both point data and cell data, it returns the (min/max)
| range of combined point and cell data. If there are no point or
| cell scalars the method will return (0,1). Note: It might be
| necessary to call Update to create or refresh the scalars before
| calling this method. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| HasAnyGhostCells(...)
| HasAnyGhostCells(self) -> bool
| C++: bool HasAnyGhostCells()
|
| Returns 1 if there are any ghost cells 0 otherwise.
|
| HasAnyGhostPoints(...)
| HasAnyGhostPoints(self) -> bool
| C++: bool HasAnyGhostPoints()
|
| Returns 1 if there are any ghost points 0 otherwise.
|
| SetCellOrderAndRationalWeights(...)
| SetCellOrderAndRationalWeights(self, cellId:int,
| cell:vtkGenericCell) -> None
| C++: void SetCellOrderAndRationalWeights(vtkIdType cellId,
| vtkGenericCell *cell)
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| cell_ghost_array
| read-only, calls GetCellGhostArray
|
| length2
| read-only, calls GetLength2
|
| mesh_m_time
| read-only, calls GetMeshMTime
|
| point_ghost_array
| read-only, calls GetPointGhostArray
|
| scalar_range
| read-only, calls GetScalarRange
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| CELL_DATA_FIELD = 2
|
| DATA_OBJECT_FIELD = 0
|
| FieldDataType = <class 'vtkmodules.vtkCommonDataModel.vtkDataSet.Field...
|
| POINT_DATA_FIELD = 1
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
class UnstructuredGrid(PointGrid, pyvista.core.filters.unstructured_grid.UnstructuredGridFilters, vtkmodules.vtkCommonDataModel.vtkUnstructuredGrid)
| UnstructuredGrid(*args, **kwargs) -> '_T'
|
| Dataset used for arbitrary combinations of all possible cell types.
|
| Can be initialized by the following:
|
| - Creating an empty grid
| - From a :vtk:`vtkPolyData` or :vtk:`vtkStructuredGrid` object
| - From cell, cell types, and point arrays
| - From a file
|
| Parameters
| ----------
| args : str, :vtk:`vtkUnstructuredGrid`, iterable
| See examples below.
|
| deep : bool, default: False
| Whether to deep copy a :vtk:`vtkUnstructuredGrid` object.
| Default is ``False``. Keyword only.
|
| validate : bool | MeshValidationFields | sequence[MeshValidationFields], default: False
| Validate the mesh using :meth:`~pyvista.DataObjectFilters.validate_mesh` after
| initialization. Set this to ``True`` to validate all fields, or specify any
| combination of fields allowed by ``validate_mesh``.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import vtk
|
| Create an empty grid
|
| >>> grid = pv.UnstructuredGrid()
|
| Copy a :vtk:`vtkUnstructuredGrid`
|
| >>> vtkgrid = vtk.vtkUnstructuredGrid()
| >>> grid = pv.UnstructuredGrid(vtkgrid)
|
| From a filename.
|
| >>> grid = pv.UnstructuredGrid(examples.hexbeamfile)
| >>> grid.plot(show_edges=True)
|
| From arrays. Here we create a single tetrahedron.
|
| >>> cells = [4, 0, 1, 2, 3]
| >>> celltypes = [pv.CellType.TETRA]
| >>> points = [
| ... [1.0, 1.0, 1.0],
| ... [1.0, -1.0, -1.0],
| ... [-1.0, 1.0, -1.0],
| ... [-1.0, -1.0, 1.0],
| ... ]
| >>> grid = pv.UnstructuredGrid(cells, celltypes, points)
| >>> grid.plot(show_edges=True)
|
| See the :ref:`create_unstructured_surface_example` example for more details
| on creating unstructured grids within PyVista.
|
| Method resolution order:
| UnstructuredGrid
| PointGrid
| _PointSet
| pyvista.core.dataset.DataSet
| pyvista.core.filters.unstructured_grid.UnstructuredGridFilters
| pyvista.core.filters.data_set.DataSetFilters
| pyvista.core.utilities.misc._BoundsSizeMixin
| pyvista.core.filters.data_object.DataObjectFilters
| pyvista.core.dataobject.DataObject
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonDataModel.vtkUnstructuredGrid
| vtkmodules.vtkCommonDataModel.vtkUnstructuredGridBase
| vtkmodules.vtkCommonDataModel.vtkPointSet
| vtkmodules.vtkCommonDataModel.vtkDataSet
| vtkmodules.vtkCommonDataModel.vtkDataObject
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, *args, deep: 'bool' = False, validate: 'bool | _NestedMeshValidationFields' = False, **kwargs) -> 'None'
| Initialize the unstructured grid.
|
| __repr__(self)
| Return the standard representation.
|
| __str__(self)
| Return the standard str representation.
|
| cast_to_explicit_structured_grid(self)
| Cast to an explicit structured grid.
|
| Returns
| -------
| pyvista.ExplicitStructuredGrid
| An explicit structured grid.
|
| Raises
| ------
| TypeError
| If the unstructured grid doesn't have the ``'BLOCK_I'``,
| ``'BLOCK_J'`` and ``'BLOCK_K'`` cells arrays.
|
| See Also
| --------
| pyvista.ExplicitStructuredGrid.cast_to_unstructured_grid
|
| Examples
| --------
| >>> from pyvista import examples
| >>> grid = examples.load_explicit_structured()
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| >>> grid = grid.hide_cells(range(80, 120))
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| >>> grid = grid.cast_to_unstructured_grid()
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| >>> grid = grid.cast_to_explicit_structured_grid()
| >>> grid.plot(color='w', show_edges=True, show_bounds=True)
|
| linear_copy(self, deep: 'bool' = False)
| Return a copy of the unstructured grid containing only linear cells.
|
| Converts the following cell types to their linear equivalents.
|
| - :attr:`~pyvista.CellType.QUADRATIC_TRIANGLE` --> :attr:`~pyvista.CellType.TRIANGLE`
| - :attr:`~pyvista.CellType.QUADRATIC_QUAD` --> :attr:`~pyvista.CellType.QUAD`
| - :attr:`~pyvista.CellType.QUADRATIC_TETRA` --> :attr:`~pyvista.CellType.TETRA`
| - :attr:`~pyvista.CellType.QUADRATIC_PYRAMID` --> :attr:`~pyvista.CellType.PYRAMID`
| - :attr:`~pyvista.CellType.QUADRATIC_WEDGE` --> :attr:`~pyvista.CellType.WEDGE`
| - :attr:`~pyvista.CellType.QUADRATIC_HEXAHEDRON` --> :attr:`~pyvista.CellType.HEXAHEDRON`
|
| Parameters
| ----------
| deep : bool, default: False
| When ``True``, makes a copy of the points array.
| Cells and cell types are always copied.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing only linear cells when
| ``deep=False``.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| cell_connectivity
| Return the cell connectivity as a numpy array.
|
| This is effectively :attr:`UnstructuredGrid.cells` without the
| padding.
|
| Returns
| -------
| numpy.ndarray
| Connectivity array.
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Return the cell connectivity for the first two cells.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.cell_connectivity[:16]
| array([ 0, 2, 8, 7, 27, 36, 90, 81, 2, 1, 4, 8, 36, 18, 54, 90])
|
| cells_dict
| Return a dictionary that contains all cells mapped from cell types.
|
| This function returns a :class:`numpy.ndarray` for each cell
| type in an ordered fashion. Note that this function only
| works with element types of fixed sizes.
|
| .. versionchanged:: 0.46
|
| An empty dict ``{}`` is returned instead of ``None`` if
| the input is empty.
|
| Returns
| -------
| dict
| A dictionary mapping containing all cells of this unstructured grid.
| Structure: vtk_enum_type (int) -> cells (:class:`numpy.ndarray`).
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Return the cells dictionary of the sample hex beam. Note how
| there is only one key/value pair as the hex beam example is
| composed of only all hexahedral cells, which is
| ``CellType.HEXAHEDRON``, which evaluates to 12.
|
| Also note how there is no padding for the cell array. This
| approach may be more helpful than the ``cells`` property when
| extracting cells.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.cells_dict # doctest:+SKIP
| {12: array([[ 0, 2, 8, 7, 27, 36, 90, 81],
| [ 2, 1, 4, 8, 36, 18, 54, 90],
| [ 7, 8, 6, 5, 81, 90, 72, 63],
| ...
| [44, 26, 62, 98, 11, 10, 13, 17],
| [89, 98, 80, 71, 16, 17, 15, 14],
| [98, 62, 53, 80, 17, 13, 12, 15]])}
|
| celltypes
| Return the cell types array.
|
| The array contains integer values corresponding to the :attr:`pyvista.Cell.type`
| of each cell in the dataset. See the :class:`pyvista.CellType` enum for more
| information about cell type.
|
| Returns
| -------
| numpy.ndarray
| Array of cell types.
|
| Examples
| --------
| This mesh contains only linear hexahedral cells, type
| :attr:`pyvista.CellType.HEXAHEDRON`, which evaluates to 12.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.celltypes
| array([12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
| 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
| 12, 12, 12, 12, 12, 12], dtype=uint8)
|
| Compare this to :attr:`~pyvista.DataSet.distinct_cell_types`.
|
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| face_locations
| Return polyhedron face locations.
|
| .. deprecated:: 0.45.0
| This property is deprecated and will be removed in a future release.
| VTK has deprecated `GetFaces` and `GetFaceLocations` in VTK 9.4 and
| may be removed in a future release of VTK. Please use
| `polyhedral_face_locations` instead.
|
| Returns
| -------
| numpy.ndarray
| Array of face locations.
|
| faces
| Return the polyhedron faces.
|
| .. deprecated:: 0.45.0
| This property is deprecated and will be removed in a future release.
| VTK has deprecated `GetFaces` and `GetFaceLocations` in VTK 9.4 and
| may be removed in a future release of VTK. Please use
| `polyhedral_faces` instead.
|
| Returns
| -------
| numpy.ndarray
| Array of faces.
|
| offset
| Return the cell locations array.
|
| This is the location of the start of each cell in
| :attr:`cell_connectivity`.
|
| Returns
| -------
| numpy.ndarray
| Array of cell offsets indicating the start of each cell.
|
| Notes
| -----
| The array returned is immutable and cannot be written to. If you
| need to modify this array, create a copy of it using
| :func:`numpy.copy`.
|
| Examples
| --------
| Return the cell offset array. Since this mesh is composed of
| all hexahedral cells, note how each cell starts at 8 greater
| than the prior cell.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.offset
| array([ 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96,
| 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200,
| 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 288, 296, 304,
| 312, 320])
|
| polyhedron_face_locations
| Return the polyhedron face locations.
|
| Returns
| -------
| numpy.ndarray
| Array of faces.
|
| polyhedron_faces
| Return the polyhedron faces.
|
| Returns
| -------
| numpy.ndarray
| Array of faces.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| cells
| Return the cell data as a numpy object.
|
| This is the old style VTK data layout::
|
| [n0, p0_0, p0_1, ..., p0_n, n1, p1_0, p1_1, ..., p1_n, ...]
|
| where ``n0`` is the number of points in cell 0, and ``pX_Y`` is the
| Y'th point in cell X.
|
| For example, a triangle and a line might be represented as::
|
| [3, 0, 1, 2, 2, 0, 1]
|
| Where the two individual cells would be ``[3, 0, 1, 2]`` and ``[2, 0, 1]``.
|
| See Also
| --------
| pyvista.DataSet.get_cell
| pyvista.UnstructuredGrid.cell_connectivity
| pyvista.UnstructuredGrid.offset
|
| Notes
| -----
| The array returned cannot be modified in place and will raise a
| ``ValueError`` if attempted.
|
| You can, however, set the cells directly. See the example.
|
| Examples
| --------
| Return the indices of the first two cells from the example hex
| beam. Note how the cells have "padding" indicating the number
| of points per cell.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.cells[:18]
| array([ 8, 0, 2, 8, 7, 27, 36, 90, 81, 8, 2, 1, 4, 8, 36, 18, 54,
| 90])
|
| While you cannot change the array inplace, you can overwrite it. For example:
|
| >>> grid.cells = [8, 0, 1, 2, 3, 4, 5, 6, 7]
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'_WRITERS': 'ClassVar[dict[str, type[BaseWriter]]]'...
|
| ----------------------------------------------------------------------
| Methods inherited from PointGrid:
|
| __new__(cls, *args, **kwargs) from pyvista.core.utilities.misc.abstract_class.<locals>
|
| plot_curvature(self: 'Self', curv_type='mean', **kwargs)
| Plot the curvature of the external surface of the grid.
|
| Parameters
| ----------
| curv_type : str, default: "mean"
| One of the following strings indicating curvature types.
| - ``'mean'``
| - ``'gaussian'``
| - ``'maximum'``
| - ``'minimum'``
|
| **kwargs : dict, optional
| Optional keyword arguments. See :func:`pyvista.plot`.
|
| Returns
| -------
| list
| Camera position, focal point, and view up. Returned when
| ``return_cpos`` is ``True``.
|
| ----------------------------------------------------------------------
| Methods inherited from _PointSet:
|
| center_of_mass(self, scalars_weight: 'bool' = False) -> 'NumpyArray[float]'
| Return the coordinates for the center of mass of the mesh.
|
| Parameters
| ----------
| scalars_weight : bool, default: False
| Flag for using the mesh scalars as weights.
|
| Returns
| -------
| numpy.ndarray
| Coordinates for the center of mass.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 1, 1))
| >>> mesh.center_of_mass()
| array([1., 1., 1.])
|
| points_to_double(self) -> 'Self'
| Convert the points datatype to double precision.
|
| Returns
| -------
| pyvista.PointSet
| Pointset with points in double precision.
|
| Notes
| -----
| This operates in place.
|
| Examples
| --------
| Create a mesh that has points of the type ``float32`` and
| convert the points to ``float64``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.points.dtype
| dtype('float32')
| >>> _ = mesh.points_to_double()
| >>> mesh.points.dtype
| dtype('float64')
|
| remove_cells(self, ind: 'VectorLike[bool] | VectorLike[int]', inplace: 'bool' = False) -> '_PointSet'
| Remove cells.
|
| Parameters
| ----------
| ind : VectorLike[int] | VectorLike[bool]
| Cell indices to be removed. The array can also be a
| boolean array of the same size as the number of cells.
|
| inplace : bool, default: False
| Whether to update the mesh in-place.
|
| Returns
| -------
| pyvista.DataSet
| Same type as the input, but with the specified cells
| removed.
|
| See Also
| --------
| :ref:`ghost_cells_example`
|
| Examples
| --------
| Remove 20 cells from an unstructured grid.
|
| >>> from pyvista import examples
| >>> import pyvista as pv
| >>> hex_mesh = pv.read(examples.hexbeamfile)
| >>> removed = hex_mesh.remove_cells(range(10, 20))
| >>> removed.plot(color='lightblue', show_edges=True, line_width=3)
|
| shallow_copy(self, to_copy: 'DataSet') -> 'None'
| Create a shallow copy from a different dataset into this one.
|
| This method mutates this dataset and returns ``None``.
|
| Parameters
| ----------
| to_copy : pyvista.DataSet
| Data object to perform the shallow copy from.
|
| translate(self: 'Self', xyz: 'VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False)
| Translate the mesh.
|
| Parameters
| ----------
| xyz : VectorLike[float]
| A vector of three floats of cartesian values to translate the mesh with.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed. This is
| only valid when not updating in place.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| pyvista.PointSet
| Translated pointset.
|
| Examples
| --------
| Create a sphere and translate it by ``(2, 1, 2)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.center
| (0.0, 0.0, 0.0)
| >>> trans = mesh.translate((2, 1, 2), inplace=True)
| >>> trans.center
| (2.0, 1.0, 2.0)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataset.DataSet:
|
| __arrow_c_stream__(self: 'Self', requested_schema: 'object | None' = None) -> 'object'
| Export :attr:`point_data` via the Arrow PyCapsule interface.
|
| Delegates to :meth:`DataSetAttributes.__arrow_c_stream__` on
| :attr:`point_data`. Callers wanting :attr:`cell_data` should use
| ``mesh.cell_data`` directly or ``mesh.to_arrow('cell')``.
|
| Requires :mod:`pyarrow`.
|
| __getattr__(self: 'Self', item: 'str') -> 'Any'
| Get attribute from base class if not found.
|
| Before falling through to the VTK base class, check whether
| ``item`` matches a pending ``pyvista.accessors`` entry point.
| A match triggers a one-shot plugin import, after which normal
| attribute resolution finds the newly-attached accessor
| descriptor.
|
| __getitem__(self: 'Self', index: "tuple[str, Literal['cell', 'point', 'field']] | str") -> 'pyvista_ndarray'
| Search both point, cell, and field data for an array.
|
| __setitem__(self: 'Self', name: 'str', scalars: '_ArrayLikeOrScalar[NumberType]') -> 'None'
| Add/set an array in the point_data, or cell_data accordingly.
|
| It depends on the array's length, or specified mode.
|
| cast_to_pointset(self: 'Self', pass_cell_data: 'bool' = False) -> 'PointSet'
| Extract the points of this dataset and return a :class:`pyvista.PointSet`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PointSet
| Dataset cast into a :class:`pyvista.PointSet`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| See Also
| --------
| :ref:`create_pointset_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Wavelet()
| >>> pointset = mesh.cast_to_pointset()
| >>> type(pointset)
| <class 'pyvista.core.pointset.PointSet'>
|
| cast_to_poly_points(self: 'Self', pass_cell_data: 'bool' = False) -> 'pv.PolyData'
| Extract the points of this dataset and return a :class:`pyvista.PolyData`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| Run the :func:`cell_data_to_point_data()
| <pyvista.DataObjectFilters.cell_data_to_point_data>` filter and pass
| cell data fields to the new pointset.
|
| Returns
| -------
| pyvista.PolyData
| Dataset cast into a :class:`pyvista.PolyData`.
|
| Notes
| -----
| This will produce a deep copy of the points and point/cell data of
| the original mesh.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> points = mesh.cast_to_poly_points(pass_cell_data=True)
| >>> type(points)
| <class 'pyvista.core.pointset.PolyData'>
| >>> points.n_arrays
| 2
| >>> points.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : Spatial Point Data
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Point Data float64 (1000,) SCALARS
| >>> points.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : None
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| Spatial Cell Data float64 (1000,)
|
| cast_to_unstructured_grid(self: 'Self') -> 'pv.UnstructuredGrid'
| Get a new representation of this object as a :class:`~pyvista.UnstructuredGrid`.
|
| .. note::
|
| Casting preserves the cell type(s) of the input. This means that any
| :class:`~pyvista.CellType.PIXEL` and :class:`~pyvista.CellType.VOXEL` cells from
| :class:`~pyvista.ImageData` or :class:`~pyvista.RectilinearGrid` are preserved.
| Use ``to_quads`` or ``to_hexahedra`` instead to convert the cell
| type for these cases.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset cast into a :class:`pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Cast a :class:`pyvista.PolyData` to a
| :class:`pyvista.UnstructuredGrid`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> type(mesh)
| <class 'pyvista.core.pointset.PolyData'>
| >>> grid = mesh.cast_to_unstructured_grid()
| >>> type(grid)
| <class 'pyvista.core.pointset.UnstructuredGrid'>
|
| cell_neighbors(self: 'Self', ind: 'int', connections: 'str' = 'points') -> 'list[int]'
| Get the cell neighbors of the ind-th cell.
|
| Concrete implementation of :vtk:`vtkDataSet.GetCellNeighbors`.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| Returns
| -------
| list[int]
| List of neighbor cells IDs for the ind-th cell.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors_levels
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Get the neighbor cell ids that have at least one point in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'points')
| [1, 2, 3, 388, 389, 11, 12, 395, 14, 209, 211, 212]
|
| Get the neighbor cell ids that have at least one edge in common with
| the 0-th cell.
|
| >>> mesh.cell_neighbors(0, 'edges')
| [1, 3, 12]
|
| For unstructured grids with cells of dimension 3 (Tetrahedron for example),
| cell neighbors can be defined using faces.
|
| >>> mesh = examples.download_tetrahedron()
| >>> mesh.cell_neighbors(0, 'faces')
| [1, 5, 7]
|
| Show a visual example.
|
| >>> from functools import partial
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>>
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.link_views()
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> for i, connection in enumerate(['points', 'edges']):
| ... pl.subplot(0, i)
| ... pl.view_xy()
| ... _ = pl.add_title(
| ... f'{connection.capitalize()} neighbors',
| ... color='red',
| ... shadow=True,
| ... font_size=8,
| ... )
| ...
| ... # Add current cell
| ... i_cell = 0
| ... current_cell = mesh.extract_cells(i_cell)
| ... _ = pl.add_mesh(current_cell, show_edges=True, color='blue')
| ... _ = add_point_labels(
| ... current_cell.cell_centers().points,
| ... labels=[f'{i_cell}'],
| ... )
| ...
| ... # Add neighbors
| ... ids = mesh.cell_neighbors(i_cell, connection)
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, color='red', show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points,
| ... labels=[f'{i}' for i in ids],
| ... )
| ...
| ... # Add other cells
| ... ids.append(i_cell)
| ... others = mesh.extract_cells(ids, invert=True)
| ... _ = pl.add_mesh(others, show_edges=True)
| >>> pl.show()
|
| cell_neighbors_levels(self: 'Self', ind: 'int', connections: 'str' = 'points', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of cell neighbors.
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| connections : str, default: "points"
| Describe how the neighbor cell(s) must be connected to the current
| cell to be considered as a neighbor.
| Can be either ``'points'``, ``'edges'`` or ``'faces'``.
|
| n_levels : int, default: 1
| Number of levels to search for cell neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.cell_neighbors`.
|
| Returns
| -------
| generator[list[int]]
| A generator of list of cell IDs for each level.
|
| Warnings
| --------
| For a :class:`pyvista.ExplicitStructuredGrid`, use
| :func:`pyvista.ExplicitStructuredGrid.neighbors`.
|
| See Also
| --------
| pyvista.DataSet.cell_neighbors
|
| Examples
| --------
| Get the cell neighbors IDs starting from the 0-th cell
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> nbr_levels = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> nbr_levels = list(nbr_levels)
| >>> nbr_levels[0]
| [1, 21, 9]
| >>> nbr_levels[1]
| [2, 8, 74, 75, 20, 507]
| >>> nbr_levels[2]
| [128, 129, 3, 453, 7, 77, 23, 506]
|
| Visualize these cells IDs.
|
| >>> from functools import partial
| >>> pv.global_theme.color_cycler = [
| ... 'red',
| ... 'green',
| ... 'blue',
| ... 'purple',
| ... ]
| >>> pl = pv.Plotter()
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Add the 0-th cell to the plotter
| >>> cell = mesh.extract_cells(0)
| >>> _ = pl.add_mesh(cell, show_edges=True)
| >>> _ = add_point_labels(cell.cell_centers().points, labels=['0'])
| >>> other_ids = [0]
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.cell_neighbors_levels(0, connections='edges', n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... cells = mesh.extract_cells(ids)
| ... _ = pl.add_mesh(cells, show_edges=True)
| ... _ = add_point_labels(
| ... cells.cell_centers().points, labels=[f'{i}'] * len(ids)
| ... )
| ... other_ids.extend(ids)
| >>>
| >>> # Add the cell IDs that are not neighbors (ie. the rest of the sphere)
| >>> cells = mesh.extract_cells(other_ids, invert=True)
| >>> _ = pl.add_mesh(cells, color='white', show_edges=True)
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(6.0)
| >>> pl.show()
|
| clear_cell_data(self: 'Self') -> 'None'
| Remove all cell arrays.
|
| clear_data(self: 'Self') -> 'None'
| Remove all arrays from point/cell/field data.
|
| Examples
| --------
| Clear all arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_data()
| >>> mesh.point_data.keys()
| []
|
| clear_point_data(self: 'Self') -> 'None'
| Remove all point arrays.
|
| Examples
| --------
| Clear all point arrays from a mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.point_data.keys()
| ['Normals']
| >>> mesh.clear_point_data()
| >>> mesh.point_data.keys()
| []
|
| copy_from(self: 'Self', mesh: '_vtk.vtkDataSet', deep: 'bool' = True) -> 'None'
| Overwrite this dataset inplace with the new dataset's geometries and data.
|
| Parameters
| ----------
| mesh : :vtk:`vtkDataSet`
| The overwriting mesh.
|
| deep : bool, default: True
| Whether to perform a deep or shallow copy.
|
| Examples
| --------
| Create two meshes and overwrite ``mesh_a`` with ``mesh_b``.
| Show that ``mesh_a`` is equal to ``mesh_b``.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = pv.Cube()
| >>> mesh_a.copy_from(mesh_b)
| >>> mesh_a == mesh_b
| True
|
| copy_meta_from(self: 'Self', ido: 'DataSet', deep: 'bool' = True) -> 'None'
| Copy pyvista meta data onto this object from another object.
|
| Parameters
| ----------
| ido : pyvista.DataSet
| Dataset to copy the metadata from.
|
| deep : bool, default: True
| Deep or shallow copy.
|
| find_cells_along_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells whose bounds intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``.
|
| Parameters
| ----------
| pointa : VectorLike
| Length 3 coordinate of the start of the line.
|
| pointb : VectorLike
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) whose bounds intersect
| the line.
|
| Warnings
| --------
| This method returns cells whose bounds intersect the line.
| This means that the line may not intersect the cell itself.
| To obtain cells that intersect the line, use
| :func:`pyvista.DataSet.find_cells_intersecting_line`.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_intersecting_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_along_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 87, 1652, 1653])
|
| find_cells_intersecting_line(self: 'Self', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', tolerance: 'float' = 0.0) -> 'NumpyArray[int]'
| Find the index of cells that intersect a line.
|
| Line is defined from ``pointa`` to ``pointb``. This
| method requires vtk version >=9.2.0.
|
| Parameters
| ----------
| pointa : sequence[float]
| Length 3 coordinate of the start of the line.
|
| pointb : sequence[float]
| Length 3 coordinate of the end of the line.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find cells along line.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell(s) that intersect
| the line.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_within_bounds
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.find_cells_intersecting_line([0.0, 0, 0], [1.0, 0, 0])
| array([ 86, 1653])
|
| find_cells_within_bounds(self: 'Self', bounds: 'BoundsTuple') -> 'NumpyArray[int]'
| Find the index of cells in this mesh within bounds.
|
| Parameters
| ----------
| bounds : sequence[float]
| Bounding box. The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Returns
| -------
| numpy.ndarray
| Index or indices of the cell in this mesh that are closest
| to the given point.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> index = mesh.find_cells_within_bounds([-2.0, 2.0, -2.0, 2.0, -2.0, 2.0])
|
| find_closest_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]', return_closest_point: 'bool' = False) -> 'int | NumpyArray[int] | tuple[int | NumpyArray[int], NumpyArray[int]]'
| Find index of closest cell in this mesh to the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float]
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| return_closest_point : bool, default: False
| If ``True``, the closest point within a mesh cell to that point is
| returned. This is not necessarily the closest nodal point on the
| mesh. Default is ``False``.
|
| Returns
| -------
| int or numpy.ndarray
| Index or indices of the cell in this mesh that is/are closest
| to the given point(s).
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| numpy.ndarray
| Point or points inside a cell of the mesh that is/are closest
| to the given point(s). Only returned if
| ``return_closest_point=True``.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of the same shape.
|
| Warnings
| --------
| This method may still return a valid cell index even if the point
| contains a value like ``numpy.inf`` or ``numpy.nan``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`distance_between_surfaces_example`
|
| Examples
| --------
| Find nearest cell on a sphere centered on the
| origin to the point ``[0.1, 0.2, 0.3]``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> point = [0.1, 0.2, 0.3]
| >>> index = mesh.find_closest_cell(point)
| >>> index
| 338
|
| Make sure that this cell indeed is the closest to
| ``[0.1, 0.2, 0.3]``.
|
| >>> import numpy as np
| >>> cell_centers = mesh.cell_centers()
| >>> relative_position = cell_centers.points - point
| >>> distance = np.linalg.norm(relative_position, axis=1)
| >>> np.argmin(distance)
| np.int64(338)
|
| Find the nearest cells to several random points that
| are centered on the origin.
|
| >>> points = 2 * np.random.default_rng().random((5000, 3)) - 1
| >>> indices = mesh.find_closest_cell(points)
| >>> indices.shape
| (5000,)
|
| For the closest cell, find the point inside the cell that is
| closest to the supplied point. The rectangle is a unit square
| with 1 cell and 4 nodal points at the corners in the plane with
| ``z`` normal and ``z=0``. The closest point inside the cell is
| not usually at a nodal point.
|
| >>> unit_square = pv.Rectangle()
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [0.25, 0.25, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([0.25, 0.25, 0. ])
|
| But, the closest point can be a nodal point, although the index of
| that point is not returned. If the closest nodal point by index is
| desired, see :func:`DataSet.find_closest_point`.
|
| >>> index, closest_point = unit_square.find_closest_cell(
| ... [1.0, 1.0, 0.5], return_closest_point=True
| ... )
| >>> closest_point
| array([1., 1., 0.])
|
| find_closest_point(self: 'Self', point: 'Iterable[float]', n: 'int' = 1) -> 'int | VectorLike[int]'
| Find index of closest point in this mesh to the given point.
|
| If wanting to query many points, use a KDTree with scipy or another
| library as those implementations will be easier to work with.
|
| See: https://github.com/pyvista/pyvista-support/issues/107
|
| Parameters
| ----------
| point : sequence[float]
| Length 3 coordinate of the point to query.
|
| n : int, optional
| If greater than ``1``, returns the indices of the ``n`` closest
| points.
|
| Returns
| -------
| int
| The index of the point in this mesh that is closest to the given point.
|
| See Also
| --------
| DataSet.find_closest_cell
| DataSet.find_containing_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
| :ref:`point_cloud_distance_example`
| :ref:`point_cloud_neighbors_example`
|
| Examples
| --------
| Find the index of the closest point to ``(0, 1, 0)``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> index = mesh.find_closest_point((0, 1, 0))
| >>> index
| 239
|
| Get the coordinate of that point.
|
| >>> mesh.points[index]
| pyvista_ndarray([-0.05218758, 0.49653167, 0.02706946], dtype=float32)
|
| find_containing_cell(self: 'Self', point: 'VectorLike[float] | MatrixLike[float]') -> 'int | NumpyArray[int]'
| Find index of a cell that contains the given point.
|
| Parameters
| ----------
| point : VectorLike[float] | MatrixLike[float],
| Coordinates of point to query (length 3) or a
| :class:`numpy.ndarray` of ``n`` points with shape ``(n, 3)``.
|
| Returns
| -------
| output : int | numpy.ndarray
| Index or indices of the cell in this mesh that contains
| the given point.
|
| .. versionchanged:: 0.35.0
| Inputs of shape ``(1, 3)`` now return a :class:`numpy.ndarray`
| of shape ``(1,)``.
|
| See Also
| --------
| DataSet.find_closest_point
| DataSet.find_closest_cell
| DataSet.find_cells_along_line
| DataSet.find_cells_within_bounds
|
| Examples
| --------
| A unit square with 16 equal sized cells is created and a cell
| containing the point ``[0.3, 0.3, 0.0]`` is found.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=[5, 5, 1], spacing=[1 / 4, 1 / 4, 0])
| >>> mesh
| ImageData...
| >>> mesh.find_containing_cell([0.3, 0.3, 0.0])
| 5
|
| A point outside the mesh domain will return ``-1``.
|
| >>> mesh.find_containing_cell([0.3, 0.3, 1.0])
| -1
|
| Find the cells that contain 1000 random points inside the mesh.
|
| >>> import numpy as np
| >>> points = np.random.default_rng().random((1000, 3))
| >>> indices = mesh.find_containing_cell(points)
| >>> indices.shape
| (1000,)
|
| get_array(self: 'Self', name: 'str', preference: 'CellLiteral | PointLiteral | FieldLiteral' = 'cell') -> 'pyvista_ndarray'
| Search both point, cell and field data for an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.pyvista_ndarray
| Requested array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array.
|
| >>> mesh.get_array('point-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Get the cell data array.
|
| >>> mesh.get_array('cell-data')
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Get the field data array.
|
| >>> mesh.get_array('field-data')
| pyvista_ndarray(['a', 'b', 'c'], dtype='<U1')
|
| get_array_association(self: 'Self', name: 'str', preference: "Literal['cell', 'point', 'field']" = 'cell') -> 'FieldAssociation'
| Get the association of an array.
|
| Parameters
| ----------
| name : str
| Name of the array.
|
| preference : str, default: "cell"
| When ``name`` is specified, this is the preferred array
| association to search for in the dataset. Must be either
| ``'point'``, ``'cell'``, or ``'field'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Field association of the array.
|
| Examples
| --------
| Create a DataSet with a variety of arrays.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['point-data'] = range(mesh.n_points)
| >>> mesh.cell_data['cell-data'] = range(mesh.n_cells)
| >>> mesh.field_data['field-data'] = ['a', 'b', 'c']
| >>> mesh.array_names
| ['point-data', 'field-data', 'cell-data']
|
| Get the point data array association.
|
| >>> mesh.get_array_association('point-data')
| <FieldAssociation.POINT: 0>
|
| Get the cell data array association.
|
| >>> mesh.get_array_association('cell-data')
| <FieldAssociation.CELL: 1>
|
| Get the field data array association.
|
| >>> mesh.get_array_association('field-data')
| <FieldAssociation.NONE: 2>
|
| get_cell(self: 'Self', index: 'int') -> 'Cell'
| Return a :class:`pyvista.Cell` object.
|
| Parameters
| ----------
| index : int
| Cell ID.
|
| Returns
| -------
| pyvista.Cell
| The i-th pyvista.Cell.
|
| Notes
| -----
| Cells returned from this method are deep copies of the original
| cells. Changing properties (for example, ``points``) will not affect
| the dataset they originated from.
|
| Examples
| --------
| Get the 0-th cell.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> cell = mesh.get_cell(0)
| >>> cell
| Cell ...
|
| Get the point ids of the first cell
|
| >>> cell.point_ids
| [0, 1, 2]
|
| Get the point coordinates of the first cell
|
| >>> cell.points
| array([[897.0, 48.8, 82.3],
| [906.6, 48.8, 80.7],
| [907.5, 55.5, 83.7]])
|
| For the first cell, get the points associated with the first edge
|
| >>> cell.edges[0].point_ids
| [0, 1]
|
| For a Tetrahedron, get the point ids of the last face
|
| >>> mesh = examples.cells.Tetrahedron()
| >>> cell = mesh.get_cell(0)
| >>> cell.faces[-1].point_ids
| [0, 2, 1]
|
| get_data_range(self: 'Self', arr_var: 'str | NumpyArray[float] | None' = None, preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'tuple[float, float]'
| Get the min and max of a named array.
|
| Parameters
| ----------
| arr_var : str, np.ndarray, optional
| The name of the array to get the range. If ``None``, the
| active scalars is used.
|
| preference : str, default: "cell"
| When scalars is specified, this is the preferred array type
| to search for in the dataset. Must be either ``'point'``,
| ``'cell'``, or ``'field'``.
|
| Returns
| -------
| tuple
| ``(min, max)`` of the named array.
|
| plot(var_item: 'list[PlottableType] | PlottableType', off_screen: 'bool | None' = None, full_screen: 'bool | None' = None, screenshot: 'str | bool | None' = None, interactive: 'bool' = True, cpos: 'CameraPositionOptions | None' = None, window_size: 'list[int] | None' = None, show_bounds: 'bool' = False, show_axes: 'bool | None' = None, notebook: 'bool | None' = None, background: 'ColorLike | None' = None, text: 'str' = '', return_img: 'bool' = False, eye_dome_lighting: 'bool' = False, volume: 'bool' = False, parallel_projection: 'bool' = False, jupyter_backend: 'JupyterBackendOptions | None' = None, return_viewer: 'bool' = False, return_cpos: 'bool' = False, jupyter_kwargs: 'dict | None' = None, theme: 'Theme | None' = None, anti_aliasing: "Literal['ssaa', 'msaa', 'fxaa'] | bool | None" = None, zoom: 'str | float | None' = None, border: 'bool' = False, border_color: 'ColorLike' = 'k', border_width: 'float' = 2.0, ssao: 'bool' = False, **kwargs) from pyvista._plot
| Plot a PyVista, numpy, or vtk object.
|
| .. versionadded:: 0.47
|
| ``plot`` can be invoked with the shell command:
|
| .. code-block:: shell
|
| pyvista plot <files> --screenshot output.png --off-screen
|
| Run ``pyvista plot --help`` for more details on available parameters.
|
| .. note::
| Providing multiple files renders them inside the same window.
|
| Parameters
| ----------
| var_item : pyvista.DataSet
| See :func:`Plotter.add_mesh <pyvista.Plotter.add_mesh>` for all
| supported types.
|
|
| off_screen : bool, optional
| Plots off screen when ``True``. Helpful for saving
| screenshots without a window popping up. Defaults to the
| global setting ``pyvista.OFF_SCREEN``.
|
| full_screen : bool, default: :attr:`pyvista.plotting.themes.Theme.full_screen`
| Opens window in full screen. When enabled, ignores
| ``window_size``.
|
| screenshot : str | bool, optional
| Saves screenshot to file when enabled. See:
| :func:`Plotter.screenshot() <pyvista.Plotter.screenshot>`.
| Default ``False``.
|
| When ``True``, takes screenshot and returns ``numpy`` array of
| image.
|
| interactive : bool, default: :attr:`pyvista.plotting.themes.Theme.interactive`
| Allows user to pan and move figure.
|
| cpos : CameraPositionOptions, optional
| List of camera position, focal point, and view up.
| See the :attr:`pyvista.Plotter.camera_position` for concrete examples
| on how to use this parameter and :ref:`cameras_api` for a detailed
| documentation on :class:`pyvista.Camera`.
|
| window_size : list[int], default: :attr:`pyvista.plotting.themes.Theme.window_size`
| Window size in pixels.
|
| show_bounds : bool, default: False
| Shows mesh bounds when ``True``.
|
| show_axes : bool, default: :attr:`pyvista.plotting.themes._AxesConfig.show`
| Shows a vtk axes widget.
|
| notebook : bool, default: :attr:`pyvista.plotting.themes.Theme.notebook`
| When ``True``, the resulting plot is placed inline a jupyter
| notebook. Assumes a jupyter console is active.
|
| background : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.background`
| Color of the background.
|
| text : str, optional
| Adds text at the bottom of the plot.
|
| return_img : bool, default: False
| Returns numpy array of the last image rendered.
|
| eye_dome_lighting : bool, optional
| Enables eye dome lighting.
|
| volume : bool, default: False
| Use the :func:`Plotter.add_volume()
| <pyvista.Plotter.add_volume>` method for volume rendering.
|
| parallel_projection : bool, default: False
| Enable parallel projection.
|
| jupyter_backend : JupyterBackendOptions, optional
| Jupyter notebook plotting backend to use.
| See available documentation at :func:`pyvista.set_jupyter_backend`
| to see all valid values for this parameter along with a detailed documentation.
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.jupyter_backend`
|
| return_viewer : bool, default: False
| Return the jupyterlab viewer, scene, or display object
| when plotting with jupyter notebook.
|
| return_cpos : bool, default: False
| Return the last camera position from the render window
| when enabled. Defaults to value in theme settings.
|
| jupyter_kwargs : dict, optional
| Keyword arguments for the Jupyter notebook plotting backend.
| See :ref:`customize_trame_toolbar_example` for an example
| using this keyword.
|
| theme : pyvista.plotting.themes.Theme, optional
| Plot-specific theme.
|
| anti_aliasing : Literal['ssaa', 'msaa', 'fxaa'] | bool, optional
| Enable or disable anti-aliasing. If ``True``, uses ``"msaa"``. If False,
| disables anti_aliasing. If a string, should be one of the following:
|
| * ``"ssaa"`` - Super-Sample Anti-Aliasing
| * ``"msaa"`` - Multi-Sample Anti-Aliasing
| * ``"fxaa"`` - Fast Approximate Anti-Aliasing
|
| Defaults to :attr:`pyvista.plotting.themes.Theme.anti_aliasing`
|
| zoom : float | str, optional
| Camera zoom. Either ``'tight'`` or a float. A value greater than 1
| is a zoom-in, a value less than 1 is a zoom-out. Must be greater
| than 0.
|
| border : bool, default: False
| Draw a border around each render window.
|
| border_color : ColorLike, default: "k"
| Either a string, rgb list, or hex color string. For example:
|
| * ``color='white'``
| * ``color='w'``
| * ``color=[1.0, 1.0, 1.0]``
| * ``color='#FFFFFF'``
|
| border_width : float, default: 2.0
| Width of the border in pixels when enabled.
|
| ssao : bool, optional
| Enable surface space ambient occlusion (SSAO). See
| :func:`Plotter.enable_ssao` for more details.
|
| **kwargs : dict, optional
| See :func:`pyvista.Plotter.add_mesh` for additional options.
|
| Returns
| -------
| cpos : list
| List of camera position, focal point, and view up.
| Returned only when ``return_cpos=True`` or set in the
| default global or plot theme. Not returned when in a
| jupyter notebook and ``return_viewer=True``.
|
| image : np.ndarray
| Numpy array of the last image when either ``return_img=True``
| or ``screenshot=True`` is set. Not returned when in a
| jupyter notebook with ``return_viewer=True``. Optionally
| contains alpha values. Sized:
|
| * [Window height x Window width x 3] if the theme sets
| ``transparent_background=False``.
| * [Window height x Window width x 4] if the theme sets
| ``transparent_background=True``.
|
| widget : ipywidgets.Widget
| IPython widget when ``return_viewer=True``.
|
| Examples
| --------
| Plot a simple sphere while showing its edges.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.plot(show_edges=True)
|
| Plot a volume mesh. Color by distance from the center of the
| ImageData. Note ``volume=True`` is passed.
|
| >>> import numpy as np
| >>> grid = pv.ImageData(dimensions=(32, 32, 32), spacing=(0.5, 0.5, 0.5))
| >>> grid['data'] = np.linalg.norm(grid.center - grid.points, axis=1)
| >>> grid['data'] = np.abs(grid['data'] - grid['data'].max()) ** 3
| >>> grid.plot(volume=True)
|
| point_cell_ids(self: 'Self', ind: 'int') -> 'list[int]'
| Get the cell IDs that use the ind-th point.
|
| Implements :vtk:`vtkDataSet.GetPointCells`.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of cell IDs using the ind-th point.
|
| Examples
| --------
| Get the cell ids using the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_cell_ids(0)
| [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=20
| ... )
| >>>
| >>> # Get the cells ids using the 0-th point
| >>> ids = mesh.point_cell_ids(0)
| >>> cells = mesh.extract_cells(ids)
| >>> _ = pl.add_mesh(cells, color='red', show_edges=True)
| >>> centers = cells.cell_centers().points
| >>> _ = pl.add_point_labels(
| ... centers,
| ... labels=[f'{i}' for i in ids],
| ... text_color='white',
| ... font_size=20,
| ... shape=None,
| ... show_points=False,
| ... )
| >>>
| >>> # Plot the other cells
| >>> others = mesh.extract_cells(
| ... [i for i in range(mesh.n_cells) if i not in ids]
| ... )
| >>> _ = pl.add_mesh(others, show_edges=True)
| >>>
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_is_inside_cell(self: 'Self', ind: 'int', point: 'VectorLike[float] | MatrixLike[float]') -> 'bool | NumpyArray[np.bool_]'
| Return whether one or more points are inside a cell.
|
| .. versionadded:: 0.35.0
|
| Parameters
| ----------
| ind : int
| Cell ID.
|
| point : VectorLike[float] | MatrixLike[float]
| Point or points to query if are inside a cell.
|
| Returns
| -------
| output : bool | numpy.ndarray
| Whether point(s) is/are inside cell. A single bool is only returned if
| the input point has shape ``(3,)``.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_hexbeam()
| >>> mesh.get_cell(0).bounds
| BoundsTuple(x_min = 0.0,
| x_max = 0.5,
| y_min = 0.0,
| y_max = 0.5,
| z_min = 0.0,
| z_max = 0.5)
| >>> mesh.point_is_inside_cell(0, [0.2, 0.2, 0.2])
| True
|
| point_neighbors(self: 'Self', ind: 'int') -> 'list[int]'
| Get the point neighbors of the ind-th point.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| Returns
| -------
| list[int]
| List of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors_levels
|
| Examples
| --------
| Get the point neighbors of the 0-th point.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> mesh.point_neighbors(0)
| [2, 226, 198, 170, 142, 114, 86, 254, 58, 30]
|
| Plot them.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Label the 0-th point
| >>> _ = pl.add_point_labels(
| ... mesh.points[0], ['0'], text_color='blue', font_size=40
| ... )
| >>>
| >>> # Get the point neighbors and plot them
| >>> neighbors = mesh.point_neighbors(0)
| >>> _ = pl.add_point_labels(
| ... mesh.points[neighbors],
| ... labels=[f'{i}' for i in neighbors],
| ... text_color='red',
| ... font_size=40,
| ... )
| >>> pl.camera_position = 'xy'
| >>> pl.camera.zoom(7.0)
| >>> pl.show()
|
| point_neighbors_levels(self: 'Self', ind: 'int', n_levels: 'int' = 1) -> 'Generator[list[int], None, None]'
| Get consecutive levels of point neighbors.
|
| Parameters
| ----------
| ind : int
| Point ID.
|
| n_levels : int, default: 1
| Number of levels to search for point neighbors.
| When equal to 1, it is equivalent to :func:`pyvista.DataSet.point_neighbors`.
|
| Returns
| -------
| generator[list[[int]]
| A generator of list of neighbor points IDs for the ind-th point.
|
| See Also
| --------
| pyvista.DataSet.point_neighbors
|
| Examples
| --------
| Get the point neighbors IDs starting from the 0-th point
| up until the third level.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(theta_resolution=10)
| >>> pt_nbr_levels = mesh.point_neighbors_levels(0, 3)
| >>> pt_nbr_levels = list(pt_nbr_levels)
| >>> pt_nbr_levels[0]
| [2, 226, 198, 170, 142, 114, 86, 30, 58, 254]
| >>> pt_nbr_levels[1]
| [3, 227, 255, 199, 171, 143, 115, 87, 59, 31]
| >>> pt_nbr_levels[2]
| [256, 32, 4, 228, 200, 172, 144, 116, 88, 60]
|
| Visualize these points IDs.
|
| >>> from functools import partial
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>>
| >>> # Define partial function to add point labels
| >>> add_point_labels = partial(
| ... pl.add_point_labels,
| ... text_color='white',
| ... font_size=40,
| ... point_size=10,
| ... always_visible=True,
| ... )
| >>>
| >>> # Add the first point label
| >>> _ = add_point_labels(mesh.points[0], labels=['0'], text_color='blue')
| >>>
| >>> # Add the neighbors to the plot
| >>> neighbors = mesh.point_neighbors_levels(0, n_levels=3)
| >>> for i, ids in enumerate(neighbors, start=1):
| ... _ = add_point_labels(
| ... mesh.points[ids],
| ... labels=[f'{i}'] * len(ids),
| ... text_color='red',
| ... )
| >>>
| >>> pl.view_xy()
| >>> pl.camera.zoom(4.0)
| >>> pl.show()
|
| rename_array(self: 'Self', old_name: 'str', new_name: 'str', preference: 'PointLiteral | CellLiteral | FieldLiteral' = 'cell') -> 'None'
| Change array name by searching for the array then renaming it.
|
| Parameters
| ----------
| old_name : str
| Name of the array to rename.
|
| new_name : str
| Name to rename the array to.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| Examples
| --------
| Create a cube, assign a point array to the mesh named
| ``'my_array'``, and rename it to ``'my_renamed_array'``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> cube = pv.Cube()
| >>> cube['my_array'] = range(cube.n_points)
| >>> cube.rename_array('my_array', 'my_renamed_array')
| >>> cube['my_renamed_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| set_active_scalars(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'cell') -> 'tuple[FieldAssociation, NumpyArray[float] | None]'
| Find the scalars by name and appropriately sets it as active.
|
| To deactivate any active scalars, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the scalars array to assign as active. If
| ``None``, deactivates active scalars for both point and
| cell data.
|
| preference : str, default: "cell"
| If there are two arrays of the same name associated with
| points or cells, it will prioritize an array matching this
| type. Can be either ``'cell'`` or ``'point'``.
|
| Returns
| -------
| pyvista.core.utilities.arrays.FieldAssociation
| Association of the scalars matching ``name``.
|
| pyvista_ndarray
| An array from the dataset matching ``name``.
|
| set_active_tensors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the tensors by name and appropriately sets it as active.
|
| To deactivate any active tensors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the tensors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| set_active_vectors(self: 'Self', name: 'str | None', preference: 'PointLiteral | CellLiteral' = 'point') -> 'None'
| Find the vectors by name and appropriately sets it as active.
|
| To deactivate any active vectors, pass ``None`` as the ``name``.
|
| Parameters
| ----------
| name : str, optional
| Name of the vectors array to assign as active.
|
| preference : str, default: "point"
| If there are two arrays of the same name associated with
| points, cells, or field data, it will prioritize an array
| matching this type. Can be either ``'cell'``,
| ``'field'``, or ``'point'``.
|
| to_arrow(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pyarrow.Table'
| Return this dataset's point or cell arrays as a :class:`pyarrow.Table`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_arrow`.
|
| Requires :mod:`pyarrow`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` /
| ``FieldAssociation.POINT`` or ``'cell'`` / ``FieldAssociation.CELL``.
|
| Returns
| -------
| pyarrow.Table
| Table with one column per (expanded) array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> mesh.to_arrow().num_rows
| 8
|
| to_pandas(self: 'Self', association: 'PointLiteral | CellLiteral' = 'point') -> 'pandas.DataFrame'
| Return this dataset's point or cell arrays as a :class:`pandas.DataFrame`.
|
| Thin wrapper around :meth:`DataSetAttributes.to_pandas`. See that
| method for column-expansion rules and dtype handling.
|
| Requires :mod:`pandas`.
|
| Parameters
| ----------
| association : str | pyvista.core.utilities.arrays.FieldAssociation, default: 'point'
| Which attribute set to convert. Accepts ``'point'`` or
| ``FieldAssociation.POINT``, which maps to :attr:`point_data`
| (``n_points`` rows); or ``'cell'`` or ``FieldAssociation.CELL``,
| which maps to :attr:`cell_data` (``n_cells`` rows). Field data is
| not supported because its arrays may have differing lengths.
|
| Returns
| -------
| pandas.DataFrame
| DataFrame with one column per (expanded) array.
|
| See Also
| --------
| :ref:`dataframe_export_example`
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['scalars'] = range(mesh.n_points)
| >>> df = mesh.to_pandas()
| >>> list(df.columns)
| ['scalars']
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataset.DataSet:
|
| active_normals
| Return the active normals as an array.
|
| Returns
| -------
| pyvista_ndarray
| Active normals of this dataset.
|
| Notes
| -----
| If both point and cell normals exist, this returns point
| normals by default.
|
| Examples
| --------
| Compute normals on an example sphere mesh and return the
| active normals for the dataset. Show that this is the same size
| as the number of points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh = mesh.compute_normals()
| >>> normals = mesh.active_normals
| >>> normals.shape
| (842, 3)
| >>> mesh.n_points
| 842
|
| active_scalars
| Return the active scalars as an array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active scalars as an array.
|
| active_scalars_info
| Return the active scalar's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active scalars.
|
| Returns
| -------
| ActiveArrayInfo
| The scalars info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point scalars are present and neither have
| been set active within at the dataset level, point scalars
| will be made active.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the active
| scalars info. Note how when the scalars are added, they
| automatically become the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Z Height')
|
| active_tensors
| Return the active tensors array.
|
| Returns
| -------
| Optional[np.ndarray]
| Active tensors array.
|
| active_tensors_info
| Return the active tensor's field and name: [field, name].
|
| Returns
| -------
| ActiveArrayInfo
| Active tensor's field and name: [field, name].
|
| active_vectors
| Return the active vectors array.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, and return the
| normals vector array.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors # doctest:+SKIP
| pyvista_ndarray([[-2.48721432e-10, -1.08815623e-09, -1.00000000e+00],
| [-2.48721432e-10, -1.08815623e-09, 1.00000000e+00],
| [-1.18888125e-01, 3.40539310e-03, -9.92901802e-01],
| ...,
| [-3.11940581e-01, -6.81432486e-02, 9.47654784e-01],
| [-2.09880397e-01, -4.65070531e-02, 9.76620376e-01],
| [-1.15582108e-01, -2.80492082e-02, 9.92901802e-01]],
| dtype=float32)
|
| active_vectors_info
| Return the active vector's association and name.
|
| Association refers to the data association (e.g. point, cell, or
| field) of the active vectors.
|
| Returns
| -------
| ActiveArrayInfo
| The vectors info in an object with namedtuple semantics,
| with attributes ``association`` and ``name``.
|
| Notes
| -----
| If both cell and point vectors are present and neither have
| been set active within at the dataset level, point vectors
| will be made active.
|
| Examples
| --------
| Create a mesh, compute the normals inplace, set the active
| vectors to the normals, and show that the active vectors are
| the ``'Normals'`` array associated with points.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> _ = mesh.compute_normals(inplace=True)
| >>> mesh.active_vectors_name = 'Normals'
| >>> mesh.active_vectors_info
| ActiveArrayInfoTuple(association=<FieldAssociation.POINT: 0>, name='Normals')
|
| area
| Return the mesh area if 2D.
|
| This will return 0 for meshes with 3D cells.
|
| Returns
| -------
| float
| Total area of the mesh.
|
| Examples
| --------
| Get the area of a square of size 2x2.
| Note 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.area
| 16.0
|
| A mesh with 3D cells does not have an area. To get
| the outer surface area, first extract the surface using
| :func:`~pyvista.DataObjectFilters.extract_surface`.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.area
| 0.0
|
| Get the area of a sphere. Discretization error results
| in slight difference from ``pi``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.area
| 3.13
|
| array_names
| Return a list of array names for the dataset.
|
| This makes sure to put the active scalars' name first in the list.
|
| Returns
| -------
| list[str]
| List of array names for the dataset.
|
| Examples
| --------
| Return the array names for a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.point_data['my_array'] = range(mesh.n_points)
| >>> mesh.array_names
| ['my_array', 'Normals']
|
| arrows
| Return a glyph representation of the active vector data as arrows.
|
| Arrows will be located at the points or cells of the mesh and
| their size will be dependent on the norm of the vector.
| Their direction will be the "direction" of the vector.
|
| If there are both active point and cell vectors, preference is
| given to the point vectors.
|
| Returns
| -------
| pyvista.PolyData
| Active vectors represented as arrows.
|
| Examples
| --------
| Create a mesh, compute the normals and set them active.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
|
| Plot the active vectors as arrows. Show the original mesh as wireframe for
| context.
|
| >>> arrows = mesh_w_normals.arrows
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe')
| >>> _ = pl.add_mesh(arrows, color='red')
| >>> pl.show()
|
| bounding_sphere
| Compute the radius and center of a bounding sphere.
|
| The sphere is exact for meshes with 4 points or less, and is otherwise approximated
| using Ritter's algorithm. Returns NaN values if there are no points.
|
| Uses :vtk:`vtkCell.ComputeBoundingSphere` internally for the computation.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| float, tuple
| Sphere radius as a float and center as a tuple of floats.
|
| Examples
| --------
| Get the bounding sphere geometry of a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> radius, center = mesh.bounding_sphere
|
| Create a sphere and plot it along with the original mesh.
|
| >>> sphere = pv.Icosphere(radius=radius, center=center)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(sphere, style='wireframe', color='black')
| >>> pl.view_xy()
| >>> pl.camera.zoom(1.5)
| >>> pl.show()
|
| bounds
| Return the bounding box of this dataset.
|
| Returns
| -------
| BoundsLike
| Bounding box of this dataset.
| The form is: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
|
| Examples
| --------
| Create a cube and return the bounds of the mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| cell
| A generator that provides an easy way to loop over all cells.
|
| To access a single cell, use :func:`pyvista.DataSet.get_cell`.
|
| .. versionchanged:: 0.39.0
| Now returns a generator instead of a list.
| Use ``get_cell(i)`` instead of ``cell[i]``.
|
| Yields
| ------
| pyvista.Cell
|
| See Also
| --------
| pyvista.DataSet.get_cell
|
| Examples
| --------
| Loop over the cells
|
| >>> import pyvista as pv
| >>> # Create a grid with 9 points and 4 cells
| >>> mesh = pv.ImageData(dimensions=(3, 3, 1))
| >>> for cell in mesh.cell: # doctest: +SKIP
| ... cell
|
| cell_data
| Return cell data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Cell data as DataSetAttributes.
|
| Examples
| --------
| Add cell arrays to a mesh and list the available ``cell_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.cell_data['my_array'] = np.random.default_rng().random(mesh.n_cells)
| >>> mesh.cell_data['my_other_array'] = np.arange(mesh.n_cells)
| >>> mesh.cell_data
| pyvista DataSetAttributes
| Association : CELL
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (6,) SCALARS
| my_other_array int64 (6,)
|
| Access an array from ``cell_data``.
|
| >>> mesh.cell_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (6,)
|
| dimensionality
| Return the number of spatial dimensions spanned by this dataset's points.
|
| This is equivalent to computing the matrix rank of the points.
|
| .. versionchanged:: 0.47
|
| This property is now generalized for all datasets. Previously, it was only available
| for datasets with a ``dimensions`` property.
|
| Notes
| -----
| :attr:`dimensionality`:
|
| - ranges from ``0`` to ``3`` for all mesh types.
| - is equivalent to :attr:`max_cell_dimensionality` and :attr:`min_cell_dimensionality`
| for gridded data types :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| Returns
| -------
| int
| The dimensionality of the dataset.
|
| See Also
| --------
| max_cell_dimensionality, min_cell_dimensionality
|
| Examples
| --------
| A single point has ``0`` dimensionality.
|
| >>> import pyvista as pv
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0]])
| >>> mesh.dimensionality
| 0
|
| With two points, the dimensionality is ``1``.
|
| >>> mesh = pv.PointSet([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
| >>> mesh.dimensionality
| 1
|
| Two-dimensional :class:`~pyvista.ImageData` (i.e. where one of its dimensions is one) has
| a dimensionality of ``2``.
|
| >>> mesh = pv.ImageData(dimensions=(100, 100, 1))
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Plane` also has dimensionality of ``2``, even if it's arbitrarily
| rotated in space.
|
| >>> mesh = pv.Plane().rotate_vector((1, 2, 3), 30)
| >>> mesh.dimensionality
| 2
|
| A :func:`~pyvista.Cube` has a dimensionality of 3.
|
| >>> mesh = pv.Cube()
| >>> mesh.dimensionality
| 3
|
| distinct_cell_types
| Return the set of distinct cell types in this dataset.
|
| The set contains :class:`~pyvista.CellType` values corresponding to the
| :attr:`pyvista.Cell.type` of each distinct cell in the dataset.
|
| .. warning::
| Computing distinct cell types can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| set[CellType]
| Set of :class:`~pyvista.CellType` values.
|
| See Also
| --------
| min_cell_dimensionality
| max_cell_dimensionality
| pyvista.UnstructuredGrid.celltypes
|
| Examples
| --------
| Load a mesh with linear :attr:`pyvista.CellType.HEXAHEDRON` cells.
|
| >>> from pyvista import examples
| >>> hex_beam = examples.load_hexbeam()
| >>> hex_beam.distinct_cell_types
| {<CellType.HEXAHEDRON: 12>}
|
| Load a mesh with mixed cells.
|
| >>> mesh = examples.download_cow()
| >>> sorted(mesh.distinct_cell_types)
| [<CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>, <CellType.QUAD: 9>]
|
| Load 2D image.
|
| >>> mesh = examples.load_logo()
| >>> mesh.distinct_cell_types
| {<CellType.PIXEL: 8>}
|
| has_nonlinear_cells
| Return True if the mesh contains any non-linear cells.
|
| .. note::
| Only :class:`~pyvista.UnstructuredGrid` can have non-linear cells. This property is
| therefore always False for all other dataset types.
|
| .. warning::
| Checking for non-linear cells can be very slow for complex meshes with VTK version
| less than 9.6.
|
| .. versionadded:: 0.47
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.cells.Hexahedron()
| >>> mesh.has_nonlinear_cells
| False
|
| >>> mesh = examples.cells.QuadraticHexahedron()
| >>> mesh.has_nonlinear_cells
| True
|
| is_empty
| Return ``True`` if there are no points.
|
| .. versionadded:: 0.45
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.PolyData()
| >>> mesh.is_empty
| True
|
| >>> mesh = pv.Sphere()
| >>> mesh.is_empty
| False
|
| length
| Return the length of the diagonal of the bounding box.
|
| Returns
| -------
| float
| Length of the diagonal of the bounding box.
|
| Examples
| --------
| Get the length of the bounding box of a cube. This should
| match ``3**(1/2)`` since it is the diagonal of a cube that is
| ``1 x 1 x 1``.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.length
| 1.7320508075688772
|
| max_cell_dimensionality
| Return the maximum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`max_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| min_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The maximum dimensionality of the dataset's cells.
|
| Examples
| --------
| :class:`~pyvista.PointSet` has no cells, so its :attr:`max_cell_dimensionality` is always
| ``0``.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere().cast_to_pointset()
| >>> mesh.max_cell_dimensionality
| 0
|
| A :class:`~pyvista.PolyData` surface mesh with 2D polygonal cells such as
| :func:`~pyvista.Sphere` has max cell dimensionality of ``2``.
|
| >>> mesh = pv.Sphere()
| >>> mesh.max_cell_dimensionality
| 2
|
| Since there are no 1D :attr:`~pyvista.CellType.LINE` or 0D
| :attr:`~pyvista.CellType.VERTEX` cells, the :attr:`min_cell_dimensionality` is also ``2``
| in this case.
|
| >>> mesh.min_cell_dimensionality
| 2
|
| A :class:`~pyvista.UnstructuredGrid` with 3D cells such as :func:`~pyvista.SolidSphere`
| has max and min cell dimensionality of ``3``.
|
| >>> mesh = pv.SolidSphere()
| >>> mesh.max_cell_dimensionality
| 3
| >>> mesh.min_cell_dimensionality
| 3
|
| A :func:`~pyvista.Line` or :func:`~pyvista.Spline` with 1D cells has a max and min
| cell dimensionality of ``1``.
|
| >>> mesh = pv.Line([0.0, 0.0, 0.0], [1.0, 1.0, 1.0])
| >>> mesh.max_cell_dimensionality
| 1
| >>> mesh.min_cell_dimensionality
| 1
|
| A curvilinear :class:`~pyvista.StructuredGrid` such as the one from
| :func:`~pyvista.examples.downloads.download_wavy` has 2D cells.
|
| >>> mesh = examples.download_wavy()[0]
| >>> mesh.max_cell_dimensionality
| 2
| >>> mesh.min_cell_dimensionality
| 2
|
| But it has a spatial :attr:`dimensionality` of ``3`` since its points span three
| dimensions.
|
| >>> mesh.dimensionality
| 3
|
| The dimensionality can vary if there are mixed cell types. E.g. load
| :func:`~pyvista.examples.downloads.download_prostar`.
|
| >>> mesh = examples.download_prostar()
| >>> sorted(mesh.distinct_cell_types) # doctest:+NORMALIZE_WHITESPACE
| [<CellType.VERTEX: 1>, <CellType.LINE: 3>, <CellType.TRIANGLE: 5>, <CellType.POLYGON: 7>,
| <CellType.QUAD: 9>, <CellType.TETRA: 10>, <CellType.HEXAHEDRON: 12>, <CellType.WEDGE: 13>,
| <CellType.PYRAMID: 14>, <CellType.POLYHEDRON: 42>]
|
| There are 3D volumetric cells, so the max dimensionality is ``3``.
|
| >>> mesh.max_cell_dimensionality
| 3
|
| And since there are :attr:`~pyvista.CellType.VERTEX` cells its
| :attr:`min_cell_dimensionality` is ``0``.
|
| >>> mesh.min_cell_dimensionality
| 0
|
| min_cell_dimensionality
| Get the minimum spatial dimensionality of all cells in this mesh.
|
| .. versionadded:: 0.47
|
| Notes
| -----
| :attr:`min_cell_dimensionality`:
|
| - is always ``0`` for :class:`~pyvista.PointSet`
| - ranges from ``0`` to ``2`` for :class:`~pyvista.PolyData`.
| - ranges from ``0`` to ``3`` for all other mesh types.
| - is equivalent to :attr:`dimensionality` for gridded data types
| :class:`~pyvista.ImageData` and :class:`~pyvista.RectilinearGrid`.
|
| See Also
| --------
| max_cell_dimensionality, dimensionality, distinct_cell_types
|
| Returns
| -------
| int
| The minimum dimensionality of the dataset's cells.
|
| Examples
| --------
| Show the max and min cell dimensionality of a :attr:`~pyvista.CellType.LINE` cell and
| :attr:`~pyvista.CellType.TRIANGLE` cell.
|
| >>> from pyvista.examples import cells
| >>> line = cells.Line()
| >>> line.max_cell_dimensionality
| 1
| >>> line.min_cell_dimensionality
| 1
|
| >>> tri = cells.Triangle()
| >>> tri.max_cell_dimensionality
| 2
| >>> tri.min_cell_dimensionality
| 2
|
| Merge the two cells and show the max and min cell dimensionality.
|
| >>> merged = line + tri
| >>> merged.max_cell_dimensionality
| 2
| >>> merged.min_cell_dimensionality
| 1
|
| n_arrays
| Return the number of arrays present in the dataset.
|
| Returns
| -------
| int
| Number of arrays present in the dataset.
|
| n_cells
| Return the number of cells in the entire dataset.
|
| Returns
| -------
| int :
| Number of cells in the entire dataset.
|
| Notes
| -----
| This returns the total number of cells -- for :class:`pyvista.PolyData`
| this includes vertices, lines, triangle strips and polygonal faces.
|
| Examples
| --------
| Create a mesh and return the number of cells in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_cells
| 6
|
| n_points
| Return the number of points in the entire dataset.
|
| Returns
| -------
| int
| Number of points in the entire dataset.
|
| Examples
| --------
| Create a mesh and return the number of points in the
| mesh.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> cube.n_points
| 8
|
| number_of_cells
| Return the number of cells.
|
| Returns
| -------
| int :
| Number of cells.
|
| number_of_points
| Return the number of points.
|
| Returns
| -------
| int :
| Number of points.
|
| point_data
| Return point data as DataSetAttributes.
|
| Returns
| -------
| DataSetAttributes
| Point data as DataSetAttributes.
|
| Examples
| --------
| Add point arrays to a mesh and list the available ``point_data``.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Cube()
| >>> mesh.clear_data()
| >>> mesh.point_data['my_array'] = np.random.default_rng().random(mesh.n_points)
| >>> mesh.point_data['my_other_array'] = np.arange(mesh.n_points)
| >>> mesh.point_data
| pyvista DataSetAttributes
| Association : POINT
| Active Scalars : my_array
| Active Vectors : None
| Active Texture : None
| Active Normals : None
| Contains arrays :
| my_array float64 (8,) SCALARS
| my_other_array int64 (8,)
|
| Access an array from ``point_data``.
|
| >>> mesh.point_data['my_other_array']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7])
|
| Or access it directly from the mesh.
|
| >>> mesh['my_array'].shape
| (8,)
|
| volume
| Return the mesh volume.
|
| This will return 0 for meshes with 2D cells.
|
| Returns
| -------
| float
| Total volume of the mesh.
|
| Examples
| --------
| Get the volume of a cube of size 4x4x4.
| Note that there are 5 points in each direction.
|
| >>> import pyvista as pv
| >>> mesh = pv.ImageData(dimensions=(5, 5, 5))
| >>> mesh.volume
| 64.0
|
| A mesh with 2D cells has no volume.
|
| >>> mesh = pv.ImageData(dimensions=(5, 5, 1))
| >>> mesh.volume
| 0.0
|
| :class:`pyvista.PolyData` is special as a 2D surface can
| enclose a 3D volume. This case uses a different methodology,
| see :func:`pyvista.PolyData.volume`.
|
| >>> mesh = pv.Sphere()
| >>> mesh.volume
| 0.51825
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataset.DataSet:
|
| active_scalars_name
| Return the name of the active scalars.
|
| Returns
| -------
| str
| Name of the active scalars.
|
| Examples
| --------
| Create a mesh, add scalars to the mesh, and return the name of
| the active scalars.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh['Z Height'] = mesh.points[:, 2]
| >>> mesh.active_scalars_name
| 'Z Height'
|
| active_tensors_name
| Return the name of the active tensor array.
|
| Returns
| -------
| str
| Name of the active tensor array.
|
| active_texture_coordinates
| Return the active texture coordinates on the points.
|
| Returns
| -------
| Optional[pyvista_ndarray]
| Active texture coordinates on the points.
|
| Examples
| --------
| Return the active texture coordinates from the globe example.
|
| >>> from pyvista import examples
| >>> globe = examples.load_globe()
| >>> globe.active_texture_coordinates
| pyvista_ndarray([[0. , 0. ],
| [0. , 0.07142857],
| [0. , 0.14285714],
| ...,
| [1. , 0.85714286],
| [1. , 0.92857143],
| [1. , 1. ]], shape=(540, 2))
|
| active_vectors_name
| Return the name of the active vectors array.
|
| Returns
| -------
| str
| Name of the active vectors array.
|
| Examples
| --------
| Create a mesh, compute the normals, set them as active, and
| return the name of the active vectors.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh_w_normals = mesh.compute_normals()
| >>> mesh_w_normals.active_vectors_name = 'Normals'
| >>> mesh_w_normals.active_vectors_name
| 'Normals'
|
| center
| Set or return the center of the bounding box.
|
| .. versionchanged:: 0.47
| Center can now be set.
|
| Returns
| -------
| tuple[float, float, float]
| Center of the bounding box.
|
| Examples
| --------
| Get the center of a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere(center=(1, 2, 0))
| >>> mesh.center
| (1.0, 2.0, 0.0)
|
| points
| Return a reference to the points as a numpy object.
|
| Returns
| -------
| pyvista_ndarray
| Reference to the points as a numpy object.
|
| Examples
| --------
| Create a mesh and return the points of the mesh as a numpy
| array.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube()
| >>> points = cube.points
| >>> points
| pyvista_ndarray([[-0.5, -0.5, -0.5],
| [-0.5, -0.5, 0.5],
| [-0.5, 0.5, 0.5],
| [-0.5, 0.5, -0.5],
| [ 0.5, -0.5, -0.5],
| [ 0.5, 0.5, -0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5]], dtype=float32)
|
| Shift these points in the z direction and show that their
| position is reflected in the mesh points.
|
| >>> points[:, 2] += 1
| >>> cube.points
| pyvista_ndarray([[-0.5, -0.5, 0.5],
| [-0.5, -0.5, 1.5],
| [-0.5, 0.5, 1.5],
| [-0.5, 0.5, 0.5],
| [ 0.5, -0.5, 0.5],
| [ 0.5, 0.5, 0.5],
| [ 0.5, 0.5, 1.5],
| [ 0.5, -0.5, 1.5]], dtype=float32)
|
| You can also update the points in-place:
|
| >>> cube.points[...] = 2 * points
| >>> cube.points
| pyvista_ndarray([[-1., -1., 1.],
| [-1., -1., 3.],
| [-1., 1., 3.],
| [-1., 1., 1.],
| [ 1., -1., 1.],
| [ 1., 1., 1.],
| [ 1., 1., 3.],
| [ 1., -1., 3.]], dtype=float32)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.unstructured_grid.UnstructuredGridFilters:
|
| clean(self, tolerance=0, remove_unused_points: 'bool' = True, produce_merge_map: 'bool' = True, average_point_data: 'bool' = True, merging_array_name=None, progress_bar: 'bool' = False)
| Merge duplicate points and remove unused points in an UnstructuredGrid.
|
| This filter, merging coincident points as defined by a merging
| tolerance and optionally removes unused points. The filter does not
| modify the topology of the input dataset, nor change the types of
| cells. It may however, renumber the cell connectivity ids.
|
| This filter implements :vtk:`vtkStaticCleanUnstructuredGrid`.
|
| Parameters
| ----------
| tolerance : float, default: 0.0
| The absolute point merging tolerance.
|
| remove_unused_points : bool, default: True
| Indicate whether points unused by any cell are removed from the
| output. Note that when this is off, the filter can successfully
| process datasets with no cells (and just points). If on in this
| case, and there are no cells, the output will be empty.
|
| produce_merge_map : bool, default: False
| Indicate whether a merge map should be produced on output.
| The merge map, if requested, maps each input point to its
| output point id, or provides a value of -1 if the input point
| is not used in the output. The merge map is associated with
| the filter's output field data and is named ``"PointMergeMap"``.
|
| average_point_data : bool, default: True
| Indicate whether point coordinates and point data of merged points
| are averaged. When ``True``, the data coordinates and attribute
| values of all merged points are averaged. When ``False``, the point
| coordinate and data of the single remaining merged point is
| retained.
|
| merging_array_name : str, optional
| If a ``merging_array_name`` is specified and exists in the
| ``point_data``, then point merging will switch into a mode where
| merged points must be both geometrically coincident and have
| matching point data. When set, ``tolerance`` has no effect.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Cleaned unstructured grid.
|
| See Also
| --------
| remove_unused_points
| Strictly remove unused points `without` merging points.
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Demonstrate cleaning an UnstructuredGrid and show how it can be used to
| average the point data across merged points.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hexbeam = examples.load_hexbeam()
| >>> hexbeam_shifted = hexbeam.translate([1, 0, 0])
| >>> hexbeam.point_data['data'] = [0] * hexbeam.n_points
| >>> hexbeam_shifted.point_data['data'] = [1] * hexbeam.n_points
| >>> merged = hexbeam.merge(hexbeam_shifted, merge_points=False)
| >>> cleaned = merged.clean(average_point_data=True)
| >>> cleaned.n_points < merged.n_points
| True
|
| Show how point averaging using the ``clean`` method with
| ``average_point_data=True`` results in averaged point data for merged
| points.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(merged, scalars='data', show_scalar_bar=False)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cleaned, scalars='data')
| >>> pl.show()
|
| delaunay_2d(self, tol=1e-05, alpha=0.0, offset=1.0, bound: 'bool' = False, inplace: 'bool' = False, edge_source=None, progress_bar: 'bool' = False) from pyvista.core.filters.poly_data.PolyDataFilters
| Apply a 2D Delaunay filter along the best fitting plane.
|
| This filter can be used to generate a 2d surface from a set of
| points on a plane. If you want to create a surface from a
| point cloud, see :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| tol : float, default: 1e-05
| Specify a tolerance to control discarding of closely
| spaced points. This tolerance is specified as a fraction
| of the diagonal length of the bounding box of the points.
|
| alpha : float, default: 0.0
| Specify alpha (or distance) value to control output of
| this filter. For a non-zero alpha value, only edges or
| triangles contained within a sphere centered at mesh
| vertices will be output. Otherwise, only triangles will be
| output.
|
| offset : float, default: 1.0
| Specify a multiplier to control the size of the initial,
| bounding Delaunay triangulation.
|
| bound : bool, default: False
| Boolean controls whether bounding triangulation points
| and associated triangles are included in the
| output. These are introduced as an initial triangulation
| to begin the triangulation process. This feature is nice
| for debugging output.
|
| inplace : bool, default: False
| If ``True``, overwrite this mesh with the triangulated
| mesh.
|
| edge_source : pyvista.PolyData, optional
| Specify the source object used to specify constrained
| edges and loops. If set, and lines/polygons are defined, a
| constrained triangulation is created. The lines/polygons
| are assumed to reference points in the input point set
| (i.e. point ids are identical in the input and
| source).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh from the 2D delaunay filter.
|
| Examples
| --------
| First, generate 30 points on circle and plot them.
|
| >>> import pyvista as pv
| >>> points = pv.Polygon(n_sides=30).points
| >>> circle = pv.PolyData(points)
| >>> circle.plot(show_edges=True, point_size=15)
|
| Use :func:`delaunay_2d` to fill the interior of the circle.
|
| >>> filled_circle = circle.delaunay_2d()
| >>> filled_circle.plot(show_edges=True, line_width=5)
|
| Use the ``edge_source`` parameter to create a constrained delaunay
| triangulation and plot it.
|
| >>> squar = pv.Polygon(n_sides=4, radius=8, fill=False)
| >>> squar = squar.rotate_z(45, inplace=False)
| >>> circ0 = pv.Polygon(center=(2, 3, 0), n_sides=30, radius=1)
| >>> circ1 = pv.Polygon(center=(-2, -3, 0), n_sides=30, radius=1)
| >>> comb = circ0.append_polydata(circ1, squar)
| >>> tess = comb.delaunay_2d(edge_source=comb)
| >>> tess.plot(cpos='xy', show_edges=True)
|
| See :ref:`create_tri_surface_example` for more examples using this filter.
|
| reconstruct_surface(self, nbr_sz=None, sample_spacing=None, progress_bar: 'bool' = False) from pyvista.core.filters.poly_data.PolyDataFilters
| Reconstruct a surface from the points in this dataset.
|
| This filter takes a list of points assumed to lie on the
| surface of a solid 3D object. A signed measure of the distance
| to the surface is computed and sampled on a regular grid. The
| grid can then be contoured at zero to extract the surface. The
| default values for neighborhood size and sample spacing should
| give reasonable results for most uses but can be set if
| desired.
|
| This is helpful when generating surfaces from point clouds and
| is more reliable than :func:`DataSetFilters.delaunay_3d`.
|
| Parameters
| ----------
| nbr_sz : int, optional
| Specify the number of neighbors each point has, used for
| estimating the local surface orientation.
|
| The default value of 20 should be fine for most
| applications, higher values can be specified if the spread
| of points is uneven. Values as low as 10 may yield
| adequate results for some surfaces. Higher values cause
| the algorithm to take longer and will cause
| errors on sharp boundaries.
|
| sample_spacing : float, optional
| The spacing of the 3D sampling grid. If not set, a
| reasonable guess will be made.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Reconstructed surface.
|
| Examples
| --------
| Create a point cloud out of a sphere and reconstruct a surface
| from it.
|
| >>> import pyvista as pv
| >>> points = pv.wrap(pv.Sphere().points)
| >>> surf = points.reconstruct_surface()
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_mesh(points)
| >>> _ = pl.add_title('Point Cloud of 3D Surface')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(surf, color=True, show_edges=True)
| >>> _ = pl.add_title('Reconstructed Surface')
| >>> pl.show()
|
| See :ref:`surface_reconstruction_example` for more examples
| using this filter.
|
| remove_unused_points(self: '_UnstructuredGridType', *, inplace: 'bool' = False) -> '_UnstructuredGridType'
| Remove points which are not used by any cells.
|
| Unlike :meth:`clean`, this filter does `not` merge points.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy is returned.
|
| See Also
| --------
| pyvista.PolyDataFilters.remove_unused_points
|
| Returns
| -------
| UnstructuredGrid
| Mesh with unused points removed.
|
| Examples
| --------
| Create :class:`~pyvista.UnstructuredGrid` with three points. The first two points are
| coincident and associated with :attr:`~pyvista.CellType.VERTEX` cells, and the third point
| is "unused" and not associated with any cells.
|
| >>> import pyvista as pv
| >>> cells = [1, 0, 1, 1]
| >>> celltypes = [pv.CellType.VERTEX, pv.CellType.VERTEX]
| >>> points = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]
| >>> grid = pv.UnstructuredGrid(cells, celltypes, points)
| >>> grid
| UnstructuredGrid (...)
| N Cells: 2
| N Points: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 1.000e+00
| N Arrays: 0
|
| Since the third point is unused, we can remove it. Note that coincident points are `not`
| merged by this filter, so the two vertex points are kept as-is.
|
| >>> grid = grid.remove_unused_points()
| >>> grid
| UnstructuredGrid (...)
| N Cells: 2
| N Points: 2
| X Bounds: 0.000e+00, 0.000e+00
| Y Bounds: 0.000e+00, 0.000e+00
| Z Bounds: 0.000e+00, 0.000e+00
| N Arrays: 0
|
| subdivide_tetra(self)
| Subdivide each tetrahedron into twelve tetrahedrons.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the subdivided tetrahedrons.
|
| Examples
| --------
| First, load a sample tetrahedral UnstructuredGrid and plot it.
|
| >>> from pyvista import examples
| >>> grid = examples.load_tetbeam()
| >>> grid.plot(show_edges=True, line_width=2)
|
| Now, subdivide and plot.
|
| >>> subdivided = grid.subdivide_tetra()
| >>> subdivided.plot(show_edges=True, line_width=2)
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_set.DataSetFilters:
|
| __add__(self: '_DataSetType', dataset)
| Combine this mesh with another into a :class:`pyvista.UnstructuredGrid`.
|
| __iadd__(self: '_DataSetType', dataset)
| Merge another mesh into this one if possible.
|
| "If possible" means that ``self`` is a :class:`pyvista.UnstructuredGrid`.
| Otherwise we have to return a new object, and the attempted in-place
| merge will raise.
|
| align(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', max_landmarks: 'int' = 100, max_mean_distance: 'float' = 1e-05, max_iterations: 'int' = 500, check_mean_distance: 'bool' = True, start_by_matching_centroids: 'bool' = True, return_matrix: 'bool' = False)
| Align a dataset to another.
|
| Uses the iterative closest point algorithm to align the points of the
| two meshes. See the VTK class :vtk:`vtkIterativeClosestPointTransform`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The target dataset to align to.
|
| max_landmarks : int, default: 100
| The maximum number of landmarks.
|
| max_mean_distance : float, default: 1e-5
| The maximum mean distance for convergence.
|
| max_iterations : int, default: 500
| The maximum number of iterations.
|
| check_mean_distance : bool, default: True
| Whether to check the mean distance for convergence.
|
| start_by_matching_centroids : bool, default: True
| Whether to start the alignment by matching centroids. Default is True.
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| aligned : pyvista.DataSet
| The dataset aligned to the target mesh.
|
| matrix : numpy.ndarray
| Transform matrix to transform the input dataset to the target dataset.
|
| See Also
| --------
| align_xyz
| Align a dataset to the x-y-z axes.
|
| Examples
| --------
| Create a cylinder, translate it, and use iterative closest point to
| align mesh to its original position.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> source = pv.Cylinder(resolution=30).triangulate().subdivide(1)
| >>> transformed = source.rotate_y(20).translate([-0.75, -0.5, 0.5])
| >>> aligned = transformed.align(source)
| >>> _, closest_points = aligned.find_closest_cell(
| ... source.points, return_closest_point=True
| ... )
| >>> dist = np.linalg.norm(source.points - closest_points, axis=1)
|
| Visualize the source, transformed, and aligned meshes.
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Before Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(transformed)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('After Alignment')
| >>> _ = pl.add_mesh(source, style='wireframe', opacity=0.5, line_width=2)
| >>> _ = pl.add_mesh(
| ... aligned,
| ... scalars=dist,
| ... scalar_bar_args={
| ... 'title': 'Distance to Source',
| ... 'fmt': '%.1E',
| ... },
| ... )
| >>> pl.show()
|
| Show that the mean distance between the source and the target is
| nearly zero.
|
| >>> np.abs(dist).mean() # doctest:+SKIP
| 9.997635192915073e-05
|
| See :ref:`icp_registration_example` for more examples using this filter.
|
| align_xyz(self: '_DataSetType', *, centered: 'bool' = True, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, cell_centers: 'bool' = False, merge_points: 'bool' = False, return_matrix: 'bool' = False)
| Align a dataset to the x-y-z axes.
|
| This filter aligns a mesh's :func:`~pyvista.principal_axes` to the world x-y-z
| axes. The principal axes are effectively used as a rotation matrix to rotate
| the dataset for the alignment. The transformation matrix used for the alignment
| can optionally be returned.
|
| Note that the transformation is not unique, since the signs of the principal
| axes are arbitrary. Consequently, applying this filter to similar meshes
| may result in dissimilar alignment (e.g. one axis may point up instead of down).
| To address this, the sign of one or two axes may optionally be "seeded" with a
| vector which approximates the axis or axes of the input. This can be useful
| for cases where the orientation of the input has a clear physical meaning.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| centered : bool, default: True
| Center the mesh at the origin. If ``False``, the aligned dataset has the
| same center as the input.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis prior to
| alignment. If set, this axis is flipped such that it best aligns with
| the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| cell_centers : bool, default: False
| Use the mesh's :meth:`~pyvista.DataObjectFilters.cell_centers` when
| computing the :func:`~pyvista.principal_axes`. Points not associated
| with cells are treated as vertex cells. By default, the mesh's
| points are used directly.
|
| .. versionadded:: 0.48
|
| merge_points : bool, default: False
| Merge coincident points with
| :meth:`~pyvista.DataSetFilters.merge_points` before computing the
| :func:`~pyvista.principal_axes`. Duplicate points can bias the
| principal axes, so enabling this can improve the alignment. By
| default the mesh's points are used as-is.
|
| .. note::
|
| Points are only merged for the alignment. The points of the
| returned mesh are *not* merged.
|
| .. versionadded:: 0.48
|
| return_matrix : bool, default: False
| Return the transform matrix as well as the aligned mesh.
|
| Returns
| -------
| pyvista.DataSet
| The dataset aligned to the x-y-z axes.
|
| numpy.ndarray
| Transform matrix to transform the input dataset to the x-y-z axes if
| ``return_matrix`` is ``True``.
|
| See Also
| --------
| pyvista.principal_axes
| Best-fit axes used by this filter for the alignment.
|
| align
| Align a source mesh to a target mesh using iterative closest point (ICP).
|
| Examples
| --------
| Create a dataset and align it to the x-y-z axes.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> aligned = mesh.align_xyz()
|
| Plot the aligned mesh along with the original. Show axes at the origin for
| context.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Align the mesh but don't center it.
|
| >>> aligned = mesh.align_xyz(centered=False)
|
| Plot the result again. The aligned mesh has the same position as the input.
|
| >>> axes = pv.AxesAssembly(position=mesh.center, scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| Note how the tip of the cone is pointing along the z-axis. This indicates that
| the cone's axis is the third principal axis. It is also pointing in the negative
| z-direction. To control the alignment so that the cone points upward, we can
| seed an approximate direction specifying what "up" means for the original mesh
| in world coordinates prior to the alignment.
|
| We can see that the cone is originally pointing downward, somewhat in the
| negative z-direction. Therefore, we can specify the ``'-z'`` vector
| as the "up" direction of the mesh's third axis prior to alignment.
|
| >>> aligned = mesh.align_xyz(axis_2_direction='-z')
|
| Plot the mesh. The cone is now pointing upward in the desired direction.
|
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| The specified direction only needs to be approximate. For example, we get the
| same result by specifying the ``'y'`` direction as the mesh's original "up"
| direction.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
| >>> axes = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes)
| >>> pl.show()
|
| We can optionally return the transformation matrix.
|
| >>> aligned, matrix = mesh.align_xyz(axis_2_direction='y', return_matrix=True)
|
| The matrix can be inverted, for example, to transform objects from the world
| axes back to the original mesh's local coordinate system.
|
| >>> inverse = pv.Transform(matrix).inverse_matrix
|
| Use the inverse to label the object's axes prior to alignment. For actors,
| we set the :attr:`~pyvista.Prop3D.user_matrix` as the inverse.
|
| >>> axes_local = pv.AxesAssembly(
| ... scale=aligned.length,
| ... user_matrix=inverse,
| ... labels=["X'", "Y'", "Z'"],
| ... )
|
| Plot the original mesh with its local axes, along with the aligned mesh and its
| axes.
|
| >>> axes_aligned = pv.AxesAssembly(scale=aligned.length)
| >>> pl = pv.Plotter()
| >>> # Add aligned mesh with axes
| >>> _ = pl.add_mesh(aligned)
| >>> _ = pl.add_actor(axes_aligned)
| >>> # Add original mesh with axes
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='black', line_width=3)
| >>> _ = pl.add_actor(axes_local)
| >>> pl.show()
|
| bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, oriented: 'bool' = False, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return a bounding box for this dataset.
|
| By default, the box is an axis-aligned bounding box (AABB) returned as a
| :class:`~pyvista.MultiBlock` with six :class:`PolyData` comprising the faces of
| the box. The blocks are named and ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame. It may also be
| oriented to generate an oriented bounding box (OBB).
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| oriented : bool, default: False
| Orient the box using this dataset's :func:`~pyvista.principal_axes`. This
| will generate a box that best fits this dataset's points. See
| :meth:`oriented_bounding_box` for more details.
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData` with six cells instead. The faces in both
| outputs are separate, i.e. there are duplicate points at the corners.
|
| See Also
| --------
| outline
| Lightweight version of this filter with fewer options.
|
| oriented_bounding_box
| Similar filter with ``oriented=True`` by default and more options.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Create a frame instead.
|
| >>> frame = mesh.bounding_box('frame')
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(frame, show_edges=True)
| >>> pl.show()
|
| Create an oriented bounding box (OBB) and compare it to the non-oriented one.
| Use the outline style for both.
|
| >>> box = mesh.bounding_box('outline')
| >>> obb = mesh.bounding_box('outline', oriented=True)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='red', line_width=5)
| >>> _ = pl.add_mesh(obb, color='blue', line_width=5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| Create the assembly and position it at the box's corner. Scale it to a fraction
| of the box's length.
|
| >>> scale = box.length / 4
| >>> axes_assembly = pv.AxesAssembly(position=point, scale=scale)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> _ = pl.view_yz()
| >>> pl.show()
|
| clip_scalar(self: '_DataSetType', scalars: 'str | None' = None, invert: 'bool' = True, value: 'float | VectorLike[float]' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False, both: 'bool' = False)
| Clip a dataset by a scalar.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to clip on. Defaults to currently active scalars.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip. When ``True``,
| only the mesh below ``value`` will be kept. When
| ``False``, only values above ``value`` will be kept.
|
| value : float | VectorLike[float], default: 0.0
| Set the clipping value. Can also be set as a range of values.
| The range produces an output similar to an isovolume filter of Paraview.
|
| inplace : bool, default: False
| Update mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| both : bool, default: False
| If ``True``, also returns the complementary clipped mesh.
|
| Returns
| -------
| output : pyvista.PolyData | tuple
| Clipped dataset if ``both=False``. If ``both=True`` then
| returns a tuple of both clipped datasets.
|
| Examples
| --------
| Remove the part of the mesh with "sample_point_scalars" above 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(scalars='sample_point_scalars', value=100)
| >>> clipped.plot()
|
| Get clipped meshes corresponding to the portions of the mesh above and below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> _below, _above = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, both=True
| ... )
|
| Remove the part of the mesh with "sample_point_scalars" below 100.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=100, invert=False
| ... )
| >>> clipped.plot()
|
| Clip the part of the mesh with "sample_point_scalars" between 200 and 250.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> dataset = examples.load_hexbeam()
| >>> clipped = dataset.clip_scalar(
| ... scalars='sample_point_scalars', value=(200, 250)
| ... )
| >>> clipped.plot()
|
| .. seealso::
|
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| clip_surface(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', invert: 'bool' = True, value: 'float' = 0.0, compute_distance: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False)
| Clip any mesh type using a :class:`pyvista.PolyData` surface mesh.
|
| The clipped mesh type matches the input type for :class:`~pyvista.PointSet` and
| :class:`~pyvista.PolyData`, otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
| Geometry of the input dataset will be preserved where possible.
| Geometries near the clip intersection will be triangulated/tessellated.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| The ``PolyData`` surface mesh to use as a clipping
| function. If this input mesh is not a :class:`pyvista.PolyData`,
| the external surface will be extracted.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| value : float, default: 0.0
| Set the clipping value of the implicit function (if
| clipping with implicit function) or scalar value (if
| clipping with scalars).
|
| compute_distance : bool, default: False
| Compute the implicit distance from the mesh onto the input
| dataset. A new array called ``'implicit_distance'`` will
| be added to the output clipped mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| DataSet
| Clipped mesh. Output type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube with a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(center=(-0.4, -0.4, -0.4))
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped = cube.clip_surface(sphere)
| >>> clipped.plot(show_edges=True, cpos='xy', line_width=3)
|
| See :ref:`clip_with_surface_example` for more examples using
| this filter.
|
| color_labels(self: 'DataSet', colors: 'str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike] | ColormapOptions' = 'glasbey_category10', *, coloring_mode: "Literal['index', 'cycle'] | None" = None, color_type: "Literal['int_rgb', 'float_rgb', 'int_rgba', 'float_rgba']" = 'int_rgb', negative_indexing: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'cell', output_scalars: 'str | None' = None, return_dict: 'bool' = False, inplace: 'bool' = False)
| Add RGB(A) scalars to labeled data.
|
| This filter adds a color array to map label values to specific colors.
| The mapping can be specified explicitly with a dictionary or implicitly
| with a colormap or sequence of colors. The implicit mapping is controlled
| with two coloring modes:
|
| - ``'index'`` : The input scalar values (label ids) are used as index values for
| indexing the specified ``colors``. This creates a direct relationship
| between labels and colors such that a given label will always have the same
| color, regardless of the number of labels present in the dataset.
|
| This option is used by default for unsigned 8-bit integer inputs, i.e.
| scalars with whole numbers and a maximum range of ``[0, 255]``.
|
| - ``'cycle'`` : The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Unlike with ``'index'`` mode, the colors are not directly mapped to
| the labels, but instead depends on the number of labels at the input.
|
| This option is used by default for floating-point inputs or for inputs
| with values out of the range ``[0, 255]``.
|
| By default, a new ``'int_rgb'`` array is added with the same name as the
| specified ``scalars`` but with ``_rgb`` appended.
|
| .. note::
| The package ``colorcet`` is required to use the default colors from the
| ``'glasbey_category10'`` colormap. For a similar, but very limited,
| alternative that does not require ``colorcet``, set ``colors='tab10'``
| and consider setting the coloring mode explicitly.
|
| .. versionadded:: 0.45
|
| See Also
| --------
| pyvista.DataSetFilters.connectivity
| Label data based on its connectivity.
|
| pyvista.ImageDataFilters.contour_labels
| Generate contours from labeled images. The contours may be colored with this filter.
|
| pack_labels
| Make labeled data contiguous. May be used as a pre-processing step before
| coloring.
|
| :ref:`anatomical_groups_example`
| Additional examples using this filter.
|
| Parameters
| ----------
| colors : str | ColorLike | Sequence[ColorLike] | dict[float, ColorLike],
| Color(s) to use. Specify a dictionary to explicitly control the mapping
| from label values to colors. Alternatively, specify colors only using a
| colormap or a sequence of colors and use ``coloring_mode`` to implicitly
| control the mapping. A single color is also supported to color the entire
| mesh with one color.
|
| By default,the ``'glasbey_category10'`` categorical colormap is used
| where the first 10 colors are the same default colors used by ``matplotlib``.
| See `colorcet categorical colormaps <https://colorcet.holoviz.org/user_guide/Categorical.html#>`_
| for more information.
|
| .. note::
| When a dictionary is specified, any scalar values for which a key is
| not provided is assigned default RGB(A) values of ``nan`` for float colors
| or ``0`` for integer colors (see ``color_type``). To ensure the color
| array has no default values, be sure to provide a mapping for any and
| all possible input label values.
|
| coloring_mode : 'index' | 'cycle', optional
| Control how colors are mapped to label values. Has no effect if ``colors``
| is a dictionary. Specify one of:
|
| - ``'index'``: The input scalar values (label ids) are used as index
| values for indexing the specified ``colors``.
| - ``'cycle'``: The specified ``colors`` are cycled through sequentially,
| and each unique value in the input scalars is assigned a color in increasing
| order. Colors are repeated if there are fewer colors than unique values
| in the input ``scalars``.
|
| By default, ``'index'`` mode is used if the values can be used to index
| the input ``colors``, and ``'cycle'`` mode is used otherwise.
|
| color_type : 'int_rgb' | 'float_rgb' | 'int_rgba' | 'float_rgba', default: 'int_rgb'
| Type of the color array to store. By default, the colors are stored as
| RGB integers to reduce memory usage.
|
| .. note::
| The color type affects the default value for unspecified colors when
| a dictionary is used. See ``colors`` for details.
|
| negative_indexing : bool, default: False
| Allow indexing ``colors`` with negative values. Only valid when
| ``coloring_mode`` is ``'index'``. This option is useful for coloring data
| with two independent categories since positive values will be colored
| differently than negative values.
|
| scalars : str, optional
| Name of scalars with labels. Defaults to currently active scalars.
|
| preference : str, default: "cell"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, optional
| Name of the color scalars array. By default, the output array
| is the same as ``scalars`` with ``_rgb`` or ``_rgba`` appended
| depending on ``color_type``.
|
| return_dict : bool, default: False
| Return a dictionary with a mapping from label values to the
| colors applied by the filter. The colors have the same type
| specified by ``color_type``.
|
| .. versionadded:: 0.46
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with RGB(A) scalars. Output type matches input type.
|
| Examples
| --------
| Load labeled data and crop it with :meth:`~pyvista.ImageDataFilters.extract_subset`
| to simplify the data.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_channels()
| >>> image_labels = image_labels.extract_subset(voi=(75, 109, 75, 109, 85, 100))
|
| Plot the dataset with default coloring using a categorical color map. The
| plotter by default uniformly samples from all 256 colors in the color map based
| on the data's range.
|
| >>> image_labels.plot(cmap='glasbey_category10')
|
| Show label ids of the dataset.
|
| >>> label_ids = np.unique(image_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Color the labels with the filter. Note that the
| ``'glasbey_category10'`` color map is used by default.
|
| >>> colored_labels, color_dict = image_labels.color_labels(return_dict=True)
|
| Plot the labels. We define a helper function to include a legend with the plot.
|
| >>> def labels_plotter(mesh, color_dict):
| ... pl = pv.Plotter()
| ... pl.add_mesh(mesh)
| ... pl.add_legend(color_dict)
| ... return pl
|
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Since the labels are unsigned integers, the ``'index'`` coloring mode is used
| by default. Unlike the uniform sampling used by the plotter in the previous
| plot, the colormap is instead indexed using the label values. This ensures
| that labels have a consistent coloring regardless of the input. For example,
| we can crop the dataset further.
|
| >>> subset_labels = image_labels.extract_subset(voi=(15, 34, 28, 34, 12, 15))
|
| And show that only three labels remain.
|
| >>> label_ids = np.unique(subset_labels.active_scalars)
| >>> label_ids
| pyvista_ndarray([1, 2, 3])
|
| Despite the changes to the dataset, the regions have the same coloring
| as before.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(return_dict=True)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Use the ``'cycle'`` coloring mode instead to map label values to colors
| sequentially.
|
| >>> colored_labels, color_dict = subset_labels.color_labels(
| ... coloring_mode='cycle', return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Map the colors explicitly using a dictionary.
|
| >>> color_dict = {0: 'black', 1: 'red', 2: 'lime', 3: 'blue', 4: 'gold'}
| >>> colored_labels = image_labels.color_labels(color_dict)
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Omit the background value from the mapping and specify float colors. When
| floats are specified, values without a mapping are assigned ``nan`` values
| and are not plotted by default.
|
| >>> color_dict.pop(0)
| 'black'
| >>> colored_labels = image_labels.color_labels(
| ... color_dict, color_type='float_rgba'
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Modify the scalars and make two of the labels negative.
|
| >>> scalars = image_labels.active_scalars
| >>> scalars[scalars > 2] *= -1
| >>> np.unique(scalars)
| pyvista_ndarray([-4, -3, 0, 1, 2])
|
| Color the mesh and enable ``negative_indexing``. With this option enabled,
| the ``'index'`` coloring mode is used by default, and therefore the positive
| values ``0``, ``1``, and ``2`` are colored with the first, second, and third
| color in the colormap, respectively. Negative values ``-3`` and ``-4`` are
| colored with the third-last and fourth-last color in the colormap, respectively.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=True, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| If ``negative_indexing`` is disabled, the coloring defaults to the
| ``'cycle'`` coloring mode instead.
|
| >>> colored_labels, color_dict = image_labels.color_labels(
| ... negative_indexing=False, return_dict=True
| ... )
| >>> labels_plotter(colored_labels, color_dict).show()
|
| Load the :func:`~pyvista.examples.downloads.download_foot_bones` dataset.
|
| >>> dataset = examples.download_foot_bones()
|
| Label the bones using :meth:`~pyvista.DataSetFilters.connectivity` and show
| the label values.
|
| >>> labeled_data = dataset.connectivity()
| >>> np.unique(labeled_data.active_scalars)
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25])
|
| Color the dataset with default arguments. Despite having 26 separately colored
| regions, the colors from the default glasbey-style colormap are all relatively
| distinct.
|
| >>> colored_labels = labeled_data.color_labels()
| >>> colored_labels.plot()
|
| Color the mesh with fewer colors than there are label values. In this case
| the ``'cycle'`` mode is used by default and the colors are reused.
|
| >>> colored_labels = labeled_data.color_labels(['red', 'lime', 'blue'])
| >>> colored_labels.plot()
|
| Color all labels with a single color.
|
| >>> colored_labels = labeled_data.color_labels('red')
| >>> colored_labels.plot()
|
| compute_boundary_mesh_quality(self: '_DataSetType', *, progress_bar: 'bool' = False)
| Compute metrics on the boundary faces of a mesh.
|
| The metrics that can be computed on the boundary faces of the mesh and are:
|
| - Distance from cell center to face center
| - Distance from cell center to face plane
| - Angle of faces plane normal and cell center to face center vector
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the computed metrics on the boundary faces of a mesh.
| ``cell_data`` as the ``"CellQuality"`` array.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_can_crushed_vtu()
| >>> cqual = mesh.compute_boundary_mesh_quality()
| >>> pl = pv.Plotter(shape=(2, 2))
| >>> _ = pl.add_mesh(mesh, show_edges=True)
| >>> pl.subplot(1, 0)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFaceCenter')
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(cqual, scalars='DistanceFromCellCenterToFacePlane')
| >>> pl.subplot(1, 1)
| >>> _ = pl.add_mesh(
| ... cqual,
| ... scalars='AngleFaceNormalAndCellCenterToFaceCenterVector',
| ... )
| >>> pl.show()
|
| compute_derivative(self: '_DataSetType', scalars: 'str | None' = None, gradient: 'bool | str' = True, divergence: 'bool | str' = False, vorticity: 'bool | str' = False, qcriterion: 'bool | str' = False, faster: 'bool' = False, preference: "Literal['point', 'cell']" = 'point', progress_bar: 'bool' = False)
| Compute derivative-based quantities of point/cell scalar field.
|
| Utilize :vtk:`vtkGradientFilter` to compute derivative-based quantities,
| such as gradient, divergence, vorticity, and Q-criterion, of the
| selected point or cell scalar field.
|
| Parameters
| ----------
| scalars : str, optional
| String name of the scalars array to use when computing the
| derivative quantities. Defaults to the active scalars in
| the dataset.
|
| gradient : bool | str, default: True
| Calculate gradient. If a string is passed, the string will be used
| for the resulting array name. Otherwise, array name will be
| ``'gradient'``. Default ``True``.
|
| divergence : bool | str, optional
| Calculate divergence. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'divergence'``.
|
| vorticity : bool | str, optional
| Calculate vorticity. If a string is passed, the string will be used
| for the resulting array name. Otherwise, default array name will be
| ``'vorticity'``.
|
| qcriterion : bool | str, optional
| Calculate qcriterion. If a string is passed, the string will be
| used for the resulting array name. Otherwise, default array name
| will be ``'qcriterion'``.
|
| faster : bool, default: False
| Use faster algorithm for computing derivative quantities. Result is
| less accurate and performs fewer derivative calculations,
| increasing computation speed. The error will feature smoothing of
| the output and possibly errors at boundaries. Option has no effect
| if DataSet is not :class:`pyvista.UnstructuredGrid`.
|
| preference : str, default: "point"
| Data type preference. Either ``'point'`` or ``'cell'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with calculated derivative.
|
| Examples
| --------
| First, plot the random hills dataset with the active elevation
| scalars. These scalars will be used for the derivative
| calculations.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> hills.plot(smooth_shading=True)
|
| Compute and plot the gradient of the active scalars.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> deriv = hills.compute_derivative()
| >>> deriv.plot(scalars='gradient')
|
| See the :ref:`gradients_example` for more examples using this filter.
|
| compute_implicit_distance(self: '_DataSetType', surface: 'DataSet | _vtk.vtkDataSet', inplace: 'bool' = False)
| Compute the implicit distance from the points to a surface.
|
| This filter will compute the implicit distance from all of the
| nodes of this mesh to a given surface. This distance will be
| added as a point array called ``'implicit_distance'``.
|
| Nodes of this mesh which are interior to the input surface
| geometry have a negative distance, and nodes on the exterior
| have a positive distance. Nodes which intersect the input
| surface has a distance of zero.
|
| Parameters
| ----------
| surface : pyvista.DataSet
| The surface used to compute the distance.
|
| inplace : bool, default: False
| If ``True``, a new scalar array will be added to the
| ``point_data`` of this mesh and the modified mesh will
| be returned. Otherwise a copy of this mesh is returned
| with that scalar field added.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the ``'implicit_distance'`` array in
| ``point_data``.
|
| See Also
| --------
| select_interior_points
|
| Examples
| --------
| Compute the distance between all the points on a sphere and a
| plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(radius=0.35)
| >>> plane = pv.Plane()
| >>> _ = sphere.compute_implicit_distance(plane, inplace=True)
| >>> dist = sphere['implicit_distance']
| >>> type(dist)
| <class 'pyvista.core.pyvista_ndarray.pyvista_ndarray'>
|
| Plot these distances as a heatmap. Note how distances above the
| plane are positive, and distances below the plane are negative.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, scalars='implicit_distance', cmap='bwr')
| >>> _ = pl.add_mesh(plane, color='w', style='wireframe')
| >>> pl.show()
|
| We can also compute the distance from all the points on the
| plane to the sphere.
|
| >>> _ = plane.compute_implicit_distance(sphere, inplace=True)
|
| Again, we can plot these distances as a heatmap. Note how
| distances inside the sphere are negative and distances outside
| the sphere are positive.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(
| ... plane,
| ... scalars='implicit_distance',
| ... cmap='bwr',
| ... clim=[-0.35, 0.35],
| ... )
| >>> _ = pl.add_mesh(sphere, color='w', style='wireframe')
| >>> pl.show()
|
| See :ref:`clip_with_surface_example` and
| :ref:`voxelize_example` for more examples using
| this filter.
|
| connectivity(self: '_DataSetType', extraction_mode: "Literal['all', 'largest', 'specified', 'cell_seed', 'point_seed', 'closest']" = 'all', variable_input: 'float | VectorLike[float] | None' = None, scalar_range: 'VectorLike[float] | None' = None, scalars: 'str | None' = None, label_regions: 'bool' = True, region_assignment_mode: "Literal['ascending', 'descending', 'unspecified']" = 'descending', region_ids: 'VectorLike[int] | None' = None, point_ids: 'VectorLike[int] | None' = None, cell_ids: 'VectorLike[int] | None' = None, closest_point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Find and label connected regions.
|
| This filter extracts cell regions based on a specified connectivity
| criterion. The extraction criterion can be controlled with
| ``extraction_mode`` to extract the largest region or the closest
| region to a seed point, for example.
|
| In general, cells are considered to be connected if they
| share a point. However, if a ``scalar_range`` is provided, cells
| must also have at least one point with scalar values in the
| specified range to be considered connected.
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. versionadded:: 0.43.0
|
| * New extraction modes: ``'specified'``, ``'cell_seed'``, ``'point_seed'``,
| and ``'closest'``.
| * Extracted regions are now sorted in descending order by
| cell count.
| * Region connectivity can be controlled using ``scalar_range``.
|
| .. deprecated:: 0.43.0
| Parameter ``largest`` is deprecated. Use ``'largest'`` or
| ``extraction_mode='largest'`` instead.
|
| Parameters
| ----------
| extraction_mode : str, default: "all"
| * ``'all'``: Extract all connected regions.
| * ``'largest'`` : Extract the largest connected region (by cell
| count).
| * ``'specified'``: Extract specific region IDs. Use ``region_ids``
| to specify the region IDs to extract.
| * ``'cell_seed'``: Extract all regions sharing the specified cell
| ids. Use ``cell_ids`` to specify the cell ids.
| * ``'point_seed'`` : Extract all regions sharing the specified
| point ids. Use ``point_ids`` to specify the point ids.
| * ``'closest'`` : Extract the region closest to the specified
| point. Use ``closest_point`` to specify the point.
|
| variable_input : float | sequence[float], optional
| The convenience parameter used for specifying any required input
| values for some values of ``extraction_mode``. Setting
| ``variable_input`` is equivalent to setting:
|
| * ``'region_ids'`` if mode is ``'specified'``.
| * ``'cell_ids'`` if mode is ``'cell_seed'``.
| * ``'point_ids'`` if mode is ``'point_seed'``.
| * ``'closest_point'`` if mode is ``'closest'``.
|
| It has no effect if the mode is ``'all'`` or ``'largest'``.
|
| scalar_range : sequence[float], optional
| Scalar range in the form ``[min, max]``. If set, the connectivity is
| restricted to cells with at least one point with scalar values in
| the specified range.
|
| scalars : str, optional
| Name of scalars to use if ``scalar_range`` is specified. Defaults
| to currently active scalars.
|
| .. note::
| This filter requires point scalars to determine region
| connectivity. If cell scalars are provided, they are first
| converted to point scalars with
| :func:`~pyvista.DataObjectFilters.cell_data_to_point_data`
| before applying the filter. The converted point scalars are
| removed from the output after applying the filter.
|
| label_regions : bool, default: True
| If ``True``, ``'RegionId'`` point and cell scalar arrays are stored.
| Each region is assigned a unique ID. IDs are zero-indexed and are
| assigned by region cell count in descending order (i.e. the largest
| region has ID ``0``).
|
| region_assignment_mode : str, default: "descending"
| Strategy used to assign connected region IDs if ``label_regions`` is True.
| Can be either:
|
| - ``"ascending"``: IDs are sorted by increasing order of cell count
| - ``"descending"``: IDs are sorted by decreasing order of cell counts
| - ``"unspecified"``: no particular order
|
| .. versionadded:: 0.47
|
| .. admonition:: ParaView compatibility
| :class: note dropdown
|
| The default value ``"descending"`` differs from ParaView's, which
| is set to ``"unspecified"`` (verified for 5.11 and 6.0 versions).
|
| region_ids : sequence[int], optional
| Region ids to extract. Only used if ``extraction_mode`` is
| ``specified``.
|
| point_ids : sequence[int], optional
| Point ids to use as seeds. Only used if ``extraction_mode`` is
| ``point_seed``.
|
| cell_ids : sequence[int], optional
| Cell ids to use as seeds. Only used if ``extraction_mode`` is
| ``cell_seed``.
|
| closest_point : sequence[int], optional
| Point coordinates in ``(x, y, z)``. Only used if
| ``extraction_mode`` is ``closest``.
|
| inplace : bool, default: False
| If ``True`` the mesh is updated in-place, otherwise a copy
| is returned. A copy is always returned if the input type is
| not ``pyvista.PolyData`` or ``pyvista.UnstructuredGrid``.
|
| progress_bar : bool, default: False
| Display a progress bar.
|
| **kwargs : dict, optional
| Used for handling deprecated parameters.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with labeled connected regions. Return type is
| ``pyvista.PolyData`` if input type is ``pyvista.PolyData`` and
| ``pyvista.UnstructuredGrid`` otherwise.
|
| See Also
| --------
| extract_largest, split_bodies, threshold, extract_values
|
| Examples
| --------
| Create a single mesh with three disconnected regions where each
| region has a different cell count.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> large = pv.Sphere(
| ... center=(-4, 0, 0), phi_resolution=40, theta_resolution=40
| ... )
| >>> medium = pv.Sphere(
| ... center=(-2, 0, 0), phi_resolution=15, theta_resolution=15
| ... )
| >>> small = pv.Sphere(center=(0, 0, 0), phi_resolution=7, theta_resolution=7)
| >>> mesh = large + medium + small
|
| Compute connectivity. There are three regions, one for each sphere.
|
| >>> conn = mesh.connectivity('all')
| >>> np.unique(conn['RegionId'])
| pyvista_ndarray([0, 1, 2])
|
| Plot the connectivity labels using :meth:`~pyvista.DataSetFilters.color_labels`.
|
| >>> def labels_plotter(dataset: pv.DataSet) -> pv.Plotter:
| ... rgb = ['red', 'green', 'blue']
| ... colored, color_dict = dataset.color_labels(rgb, return_dict=True)
| ... pl = pv.Plotter()
| ... pl.add_mesh(colored, show_edges=True)
| ... pl.add_legend(color_dict)
| ... pl.camera_position = pv.CameraPosition(
| ... position=(3.8, 5.8, 5.8),
| ... focal_point=(-2.0, 0.0, 0.0),
| ... viewup=(0.0, 0.0, 1.0),
| ... )
| ... return pl
| >>>
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
|
| Restrict connectivity to a scalar range.
|
| >>> mesh['y_coordinates'] = mesh.points[:, 1]
| >>> conn = mesh.connectivity('all', scalar_range=[-1, 0])
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the region closest to the origin.
|
| >>> conn = mesh.connectivity('closest', (0, 0, 0))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract a region using a cell ID ``3100`` as a seed.
|
| >>> conn = mesh.connectivity('cell_seed', 3100)
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest region.
|
| >>> conn = mesh.connectivity('largest')
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| Extract the largest and smallest regions by specifying their
| region IDs. Note that the region IDs of the output differ from
| the specified IDs since the input has three regions but the output
| only has two.
|
| >>> large_id = 0 # largest always has ID '0'
| >>> small_id = 2 # smallest has ID 'N-1' with N=3 regions
| >>> conn = mesh.connectivity('specified', (small_id, large_id))
| >>> pl = labels_plotter(conn)
| >>> pl.show()
|
| contour(self: '_DataSetType', isosurfaces: 'int | Sequence[float]' = 10, scalars: 'str | NumpyArray[float] | None' = None, compute_normals: 'bool' = False, compute_gradients: 'bool' = False, compute_scalars: 'bool' = True, rng: 'VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', method: "Literal['contour', 'marching_cubes', 'flying_edges']" = 'contour', progress_bar: 'bool' = False)
| Contour an input self by an array.
|
| ``isosurfaces`` can be an integer specifying the number of
| isosurfaces in the data range or a sequence of values for
| explicitly setting the isosurfaces.
|
| Parameters
| ----------
| isosurfaces : int | sequence[float], optional
| Number of isosurfaces to compute across valid data range or a
| sequence of float values to explicitly use as the isosurfaces.
|
| scalars : str | array_like[float], optional
| Name or array of scalars to threshold on. If this is an array, the
| output of this filter will save them as ``"Contour Data"``.
| Defaults to currently active scalars.
|
| compute_normals : bool, default: False
| Compute normals for the dataset.
|
| compute_gradients : bool, default: False
| Compute gradients for the dataset.
|
| compute_scalars : bool, default: True
| Preserves the scalar values that are being contoured.
|
| rng : sequence[float], optional
| If an integer number of isosurfaces is specified, this is
| the range over which to generate contours. Default is the
| scalars array's full data range.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| method : str, default: "contour"
| Specify to choose which vtk filter is used to create the contour.
| Must be one of ``'contour'``, ``'marching_cubes'`` and
| ``'flying_edges'``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Contoured surface.
|
| Examples
| --------
| Generate contours for the random hills dataset.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> contours = hills.contour()
| >>> contours.plot(line_width=5)
|
| Generate the surface of a mobius strip using flying edges.
|
| >>> import pyvista as pv
| >>> a = 0.4
| >>> b = 0.1
| >>> def f(x, y, z):
| ... xx = x * x
| ... yy = y * y
| ... zz = z * z
| ... xyz = x * y * z
| ... xx_yy = xx + yy
| ... a_xx = a * xx
| ... b_yy = b * yy
| ... return (
| ... (xx_yy + 1) * (a_xx + b_yy)
| ... + zz * (b * xx + a * yy)
| ... - 2 * (a - b) * xyz
| ... - a * b * xx_yy
| ... ) ** 2 - 4 * (xx + yy) * (a_xx + b_yy - xyz * (a - b)) ** 2
| >>> n = 100
| >>> x_min, y_min, z_min = -1.35, -1.7, -0.65
| >>> grid = pv.ImageData(
| ... dimensions=(n, n, n),
| ... spacing=(
| ... abs(x_min) / n * 2,
| ... abs(y_min) / n * 2,
| ... abs(z_min) / n * 2,
| ... ),
| ... origin=(x_min, y_min, z_min),
| ... )
| >>> x, y, z = grid.points.T
| >>> values = f(x, y, z)
| >>> out = grid.contour(
| ... 1,
| ... scalars=values,
| ... rng=[0, 0],
| ... method='flying_edges',
| ... )
| >>> out.plot(color='lightblue', smooth_shading=True)
|
| See :ref:`using_filters_example`, :ref:`marching_cubes_example`, or
| :ref:`gyroid_example` for more examples using this
| filter.
|
| decimate_boundary(self: '_DataSetType', target_reduction: 'float' = 0.5, progress_bar: 'bool' = False)
| Return a decimated version of a triangulation of the boundary.
|
| Only the outer surface of the input dataset will be considered.
|
| Parameters
| ----------
| target_reduction : float, default: 0.5
| Fraction of the original mesh to remove.
| TargetReduction is set to ``0.9``, this filter will try to reduce
| the data set to 10% of its original size and will remove 90%
| of the input triangles.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Decimated boundary.
|
| Examples
| --------
| See the :ref:`linked_views_example` example.
|
| delaunay_3d(self: '_DataSetType', alpha: 'float' = 0.0, tol: 'float' = 0.001, offset: 'float' = 2.5, progress_bar: 'bool' = False)
| Construct a 3D Delaunay triangulation of the mesh.
|
| This filter can be used to generate a 3D tetrahedral mesh from
| a surface or scattered points. If you want to create a
| surface from a point cloud, see
| :func:`pyvista.PolyDataFilters.reconstruct_surface`.
|
| Parameters
| ----------
| alpha : float, default: 0.0
| Distance value to control output of this filter. For a
| non-zero alpha value, only vertices, edges, faces, or
| tetrahedra contained within the circumsphere (of radius
| alpha) will be output. Otherwise, only tetrahedra will be
| output.
|
| tol : float, default: 0.001
| Tolerance to control discarding of closely spaced points.
| This tolerance is specified as a fraction of the diagonal
| length of the bounding box of the points.
|
| offset : float, default: 2.5
| Multiplier to control the size of the initial, bounding
| Delaunay triangulation.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the Delaunay triangulation.
|
| Examples
| --------
| Generate a 3D Delaunay triangulation of a surface mesh of a
| sphere and plot the interior edges generated.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=5, phi_resolution=5)
| >>> grid = sphere.delaunay_3d()
| >>> edges = grid.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`convex_hull_example` for more examples using this filter.
|
| explode(self: '_DataSetType', factor: 'float' = 0.1)
| Push each individual cell away from the center of the dataset.
|
| Parameters
| ----------
| factor : float, default: 0.1
| How much each cell will move from the center of the dataset
| relative to its distance from it. Increase this number to push the
| cells farther away.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid containing the exploded cells.
|
| Notes
| -----
| This is similar to :func:`shrink <pyvista.DataSetFilters.shrink>`
| except that it does not change the size of the cells.
|
| Examples
| --------
| >>> import numpy as np
| >>> import pyvista as pv
| >>> xrng = np.linspace(0, 1, 3)
| >>> yrng = np.linspace(0, 2, 4)
| >>> zrng = np.linspace(0, 3, 5)
| >>> grid = pv.RectilinearGrid(xrng, yrng, zrng)
| >>> exploded = grid.explode()
| >>> exploded.plot(show_edges=True)
|
| extract_cells(self: '_DataSetType', ind: 'int | VectorLike[int]', invert: 'bool' = False, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid.
|
| Parameters
| ----------
| ind : int | VectorLike[int]
| Cell indices to extract. Can be a single int or a vector of ints.
| A bool vector is also supported; the vector size should match the number of cells.
|
| invert : bool, default: False
| Invert the selection.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_points, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = pv.read(examples.hexbeamfile)
| >>> subset = grid.extract_cells(range(20))
| >>> subset.n_cells
| 20
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(grid, style='wireframe', line_width=5, color='black')
| >>> actor = pl.add_mesh(subset, color='grey')
| >>> pl.show()
|
| extract_cells_by_type(self: '_DataSetType', cell_types: 'int | VectorLike[int]', progress_bar: 'bool' = False)
| Extract cells of a specified type.
|
| Given an input dataset and a list of cell types, produce an output
| dataset containing only cells of the specified type(s). Note that if
| the input dataset is homogeneous (e.g., all cells are of the same type)
| and the cell type is one of the cells specified, then the input dataset
| is shallow copied to the output.
|
| The type of output dataset is always the same as the input type. Since
| structured types of data (i.e., :class:`pyvista.ImageData`,
| :class:`pyvista.StructuredGrid`, :class:`pyvista.RectilinearGrid`)
| are all composed of a cell of the same
| type, the output is either empty, or a shallow copy of the input.
| Unstructured data (:class:`pyvista.UnstructuredGrid`,
| :class:`pyvista.PolyData`) input may produce a subset of the input data
| (depending on the selected cell types).
|
| Parameters
| ----------
| cell_types : int | VectorLike[int]
| The cell types to extract. Must be a single or list of integer cell
| types. See :class:`pyvista.CellType`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with the extracted cells. Type is the same as the input.
|
| Notes
| -----
| Unlike :func:`pyvista.DataSetFilters.extract_cells` which always
| produces a :class:`pyvista.UnstructuredGrid` output, this filter
| produces the same output type as input type.
|
| Examples
| --------
| Create an unstructured grid with both hexahedral and tetrahedral
| cells and then extract each individual cell type.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> beam = examples.load_hexbeam()
| >>> beam = beam.translate([1, 0, 0])
| >>> ugrid = beam + examples.load_tetbeam()
| >>> hex_cells = ugrid.extract_cells_by_type(pv.CellType.HEXAHEDRON)
| >>> tet_cells = ugrid.extract_cells_by_type(pv.CellType.TETRA)
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> _ = pl.add_text('Extracted Hexahedron cells')
| >>> _ = pl.add_mesh(hex_cells, show_edges=True)
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_text('Extracted Tetrahedron cells')
| >>> _ = pl.add_mesh(tet_cells, show_edges=True)
| >>> pl.show()
|
| extract_feature_edges(self: '_DataSetType', feature_angle: 'float' = 30.0, boundary_edges: 'bool' = True, non_manifold_edges: 'bool' = True, feature_edges: 'bool' = True, manifold_edges: 'bool' = True, clear_data: 'bool' = False, progress_bar: 'bool' = False) -> 'PolyData'
| Extract edges from the surface of the mesh.
|
| If the given mesh is not PolyData, the external surface of the given
| mesh is extracted and used.
|
| From vtk documentation, the edges are one of the following:
|
| 1) Boundary (used by one polygon) or a line cell.
| 2) Non-manifold (used by three or more polygons).
| 3) Feature edges (edges used by two triangles and whose
| dihedral angle > feature_angle).
| 4) Manifold edges (edges used by exactly two polygons).
|
| Parameters
| ----------
| feature_angle : float, default: 30.0
| Feature angle (in degrees) used to detect sharp edges on
| the mesh. Used only when ``feature_edges=True``.
|
| boundary_edges : bool, default: True
| Extract the boundary edges.
|
| non_manifold_edges : bool, default: True
| Extract non-manifold edges.
|
| feature_edges : bool, default: True
| Extract edges exceeding ``feature_angle``.
|
| manifold_edges : bool, default: True
| Extract manifold edges.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Extracted edges.
|
| Examples
| --------
| Extract the edges from an unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> feat_edges = hex_beam.extract_feature_edges()
| >>> feat_edges.clear_data() # clear array data for plotting
| >>> feat_edges.plot(line_width=10)
|
| See the :ref:`extract_edges_example` for more examples using this filter.
|
| extract_geometry(self: '_DataSetType', extent: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False) -> 'PolyData'
| Extract the outer surface of a volume or structured grid dataset.
|
| This will extract all 0D, 1D, and 2D cells producing the
| boundary faces of the dataset.
|
| .. deprecated:: 0.47.0
| Use :meth:`~pyvista.DataObjectFilters.extract_surface` instead
| with keyword `algorithm=None`.
|
| Parameters
| ----------
| extent : VectorLike[float], optional
| Specify a ``(x_min, x_max, y_min, y_max, z_min, z_max)`` bounding box to
| clip data.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface of the dataset.
|
| Examples
| --------
| Extract the surface of a sample unstructured grid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> hex_beam.extract_geometry() # doctest:+SKIP
| PolyData (...)
| N Cells: 88
| N Points: 90
| N Strips: 0
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| N Arrays: 3
|
| See :ref:`surface_smoothing_example` for more examples using this filter.
|
| extract_largest(self: '_DataSetType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Extract largest connected set in mesh.
|
| Can be used to reduce residues obtained when generating an
| isosurface. Works only if residues are not connected (share
| at least one point with) the main component of the image.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Largest connected set in the dataset. Return type matches input.
|
| Examples
| --------
| Join two meshes together, extract the largest, and plot it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere() + pv.Cube()
| >>> largest = mesh.extract_largest()
| >>> largest.plot()
|
| See :ref:`connectivity_example` and :ref:`volumetric_analysis_example` for
| more examples using this filter.
|
| .. seealso::
| :func:`pyvista.DataSetFilters.connectivity`
|
| extract_points(self: '_DataSetType', ind: 'int | VectorLike[int] | VectorLike[bool]', adjacent_cells: 'bool' = True, include_cells: 'bool' = True, pass_cell_ids: 'bool' = True, pass_point_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the grid (with cells) that contains any of the given point indices.
|
| Parameters
| ----------
| ind : sequence[int]
| Sequence of point indices to be extracted.
|
| adjacent_cells : bool, default: True
| If ``True``, extract the cells that contain at least one of
| the extracted points. If ``False``, extract the cells that
| contain exclusively points from the extracted points list.
| Has no effect if ``include_cells`` is ``False``.
|
| include_cells : bool, default: True
| Specifies if the cells shall be returned or not.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| .. versionadded:: 0.47
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_cells, extract_values
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Subselected grid.
|
| Examples
| --------
| Extract all the points of a sphere with a Z coordinate greater than 0
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> extracted = sphere.extract_points(
| ... sphere.points[:, 2] > 0, include_cells=False
| ... )
| >>> extracted.clear_data() # clear for plotting
| >>> extracted.plot()
|
| extract_values(self: '_DataSetType', values: 'float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str] | None' = None, *, ranges: 'VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str] | None' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', invert: 'bool' = False, adjacent_cells: 'bool' = True, include_cells: 'bool | None' = None, split: 'bool' = False, pass_point_ids: 'bool' = True, pass_cell_ids: 'bool' = True, progress_bar: 'bool' = False)
| Return a subset of the mesh based on the value(s) of point or cell data.
|
| Points and cells may be extracted with a single value, multiple values, a range
| of values, or any mix of values and ranges. This enables threshold-like
| filtering of data in a discontinuous manner to extract a single label or groups
| of labels from categorical data, or to extract multiple regions from continuous
| data. Extracted values may optionally be split into separate meshes.
|
| This filter operates on point data and cell data distinctly:
|
| **Point data**
|
| All cells with at least one point with the specified value(s) are returned.
| Optionally, set ``adjacent_cells`` to ``False`` to only extract points from
| cells where all points in the cell strictly have the specified value(s).
| In these cases, a point is only included in the output if that point is part
| of an extracted cell.
|
| Alternatively, set ``include_cells`` to ``False`` to exclude cells from
| the operation completely and extract all points with a specified value.
|
| **Cell Data**
|
| Only the cells (and their points) with the specified values(s) are included
| in the output.
|
| Internally, :meth:`~pyvista.DataSetFilters.extract_points` is called to extract
| points for point data, and :meth:`~pyvista.DataSetFilters.extract_cells` is
| called to extract cells for cell data.
|
| By default, two arrays are included with the output: ``'vtkOriginalPointIds'``
| and ``'vtkOriginalCellIds'``. These arrays can be used to link the filtered
| points or cells directly to the input.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : ArrayLike[float] | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| invert : bool, default: False
| Invert the extraction values. If ``True`` extract the points (with cells)
| which do *not* have the specified values.
|
| adjacent_cells : bool, default: True
| If ``True``, include cells (and their points) that contain at least one of
| the extracted points. If ``False``, only include cells that contain
| exclusively points from the extracted points list. Has no effect if
| ``include_cells`` is ``False``. Has no effect when extracting values from
| cell data.
|
| include_cells : bool, default: None
| Specify if cells shall be used for extraction or not. If ``False``, points
| with the specified values are extracted regardless of their cell
| connectivity, and all cells at the output will be vertex cells (one for each
| point.) Has no effect when extracting values from cell data.
|
| By default, this value is ``True`` if the input has at least one cell and
| ``False`` otherwise.
|
| split : bool, default: False
| If ``True``, each value in ``values`` and each range in ``range`` is
| extracted independently and returned as a :class:`~pyvista.MultiBlock`.
| The number of blocks returned equals the number of input values and ranges.
| The blocks may be named if a dictionary is used as input. See ``values``
| and ``ranges`` for details.
|
| .. note::
| Output blocks may contain empty meshes if no values meet the extraction
| criteria. This can impact plotting since empty meshes cannot be plotted
| by default. Use :meth:`pyvista.MultiBlock.clean` on the output to remove
| empty meshes, or set ``pv.global_theme.allow_empty_mesh = True`` to
| enable plotting empty meshes.
|
| pass_point_ids : bool, default: True
| Add a point array ``'vtkOriginalPointIds'`` that identifies the original
| points the extracted points correspond to.
|
| pass_cell_ids : bool, default: True
| Add a cell array ``'vtkOriginalCellIds'`` that identifies the original cells
| the extracted cells correspond to.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| split_values
| Wrapper around this filter to split values and return a :class:`~pyvista.MultiBlock`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Similar filter specialized for :class:`~pyvista.ImageData`.
| extract_points
| Extract a subset of a mesh's points.
| extract_cells
| Extract a subset of a mesh's cells.
| threshold
| Similar filter for thresholding a mesh by value.
| partition
| Split a mesh into a number of sub-parts.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
| Returns
| -------
| output : pyvista.UnstructuredGrid | pyvista.MultiBlock
| An extracted mesh or a composite of extracted meshes, depending on ``split``.
|
| Examples
| --------
| Extract a single value from a grid's point data.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> extracted = mesh.extract_values(0)
|
| Plot extracted values. Since adjacent cells are included by default, points with
| values other than ``0`` are included in the output.
|
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(81.0))
| >>> extracted.plot()
|
| Set ``include_cells=False`` to only extract points. The output scalars now
| strictly contain zeros.
|
| >>> extracted = mesh.extract_values(0, include_cells=False)
| >>> extracted.get_data_range()
| (np.float64(0.0), np.float64(0.0))
| >>> extracted.plot(render_points_as_spheres=True, point_size=100, color=True)
|
| Use ``ranges`` to extract values from a grid's point data in range.
|
| Here, we use ``+/-`` infinity to extract all values of ``100`` or less.
|
| >>> extracted = mesh.extract_values(ranges=[-np.inf, 100])
| >>> extracted.plot()
|
| Extract every third cell value from cell data.
|
| >>> mesh = examples.load_hexbeam()
| >>> lower, upper = mesh.get_data_range()
| >>> step = 3
| >>> extracted = mesh.extract_values(
| ... range(lower, upper, step) # values 0, 3, 6, ...
| ... )
|
| Plot result and show an outline of the input for context.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(extracted)
| >>> _ = pl.add_mesh(mesh.extract_all_edges())
| >>> pl.show()
|
| Any combination of values and ranges may be specified.
|
| E.g. extract a single value and two ranges, and split the result into separate
| blocks of a MultiBlock.
|
| >>> extracted = mesh.extract_values(
| ... values=18, ranges=[[0, 8], [29, 40]], split=True
| ... )
| >>> extracted
| MultiBlock (...)
| N Blocks: 3
| X Bounds: 0.000e+00, 1.000e+00
| Y Bounds: 0.000e+00, 1.000e+00
| Z Bounds: 0.000e+00, 5.000e+00
| >>> extracted.plot(multi_colors=True)
|
| Extract values from multi-component scalars.
|
| First, create a point cloud with a 3-component RGB color array.
|
| >>> rng = np.random.default_rng(seed=1)
| >>> points = rng.random((30, 3))
| >>> colors = rng.random((30, 3))
| >>> point_cloud = pv.PointSet(points)
| >>> point_cloud['colors'] = colors
| >>> plot_kwargs = dict(render_points_as_spheres=True, point_size=50, rgb=True)
| >>> point_cloud.plot(**plot_kwargs)
|
| Extract values from a single component.
|
| E.g. extract points with a strong red component (i.e. > 0.8).
|
| >>> extracted = point_cloud.extract_values(ranges=[0.8, 1.0], component_mode=0)
| >>> extracted.plot(**plot_kwargs)
|
| Extract values from all components.
|
| E.g. extract points where all RGB components are dark (i.e. < 0.5).
|
| >>> extracted = point_cloud.extract_values(
| ... ranges=[0.0, 0.5], component_mode='all'
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Extract specific multi-component values.
|
| E.g. round the scalars to create binary RGB components, and extract only green
| and blue components.
|
| >>> point_cloud['colors'] = np.round(point_cloud['colors'])
| >>> green = [0, 1, 0]
| >>> blue = [0, 0, 1]
| >>>
| >>> extracted = point_cloud.extract_values(
| ... values=[blue, green],
| ... component_mode='multi',
| ... )
| >>> extracted.plot(**plot_kwargs)
|
| Use the original IDs returned by the extraction to modify the original point
| cloud.
|
| For example, change the color of the blue and green points to yellow.
|
| >>> point_ids = extracted['vtkOriginalPointIds']
| >>> yellow = [1, 1, 0]
| >>> point_cloud['colors'][point_ids] = yellow
| >>> point_cloud.plot(**plot_kwargs)
|
| gaussian_splatting(self: '_DataSetType', *, radius: 'float' = 0.1, dimensions: 'VectorLike[int]' = (50, 50, 50), progress_bar: 'bool' = False)
| Splat points into a volume using a Gaussian distribution.
|
| This filter uses :vtk:`vtkGaussianSplatter` to splat points into a volume
| dataset. Each point is surrounded with a Gaussian distribution function
| weighted by input scalar data. The distribution function is volumetrically
| sampled to create a structured dataset.
|
| .. versionadded:: 0.46
|
| Parameters
| ----------
| radius : float, default: 0.1
| This value is expressed as a percentage of the length of the longest side of
| the sampling volume. This determines the "width" of the splatter in
| terms of the distribution. Smaller numbers greatly reduce execution time.
|
| dimensions : VectorLike[int], default: (50, 50, 50)
| Sampling dimensions of the structured point set. Higher values produce better
| results but are much slower. This is the :attr:`~pyvista.ImageData.dimensions`
| of the returned :class:`~pyvista.ImageData`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.ImageData
| Image data with scalar values representing the splatting
| of the points.
|
| See Also
| --------
| voxelize_binary_mask
| Alternative method for generating :class:`~pyvista.ImageData` from a dataset.
|
| Examples
| --------
| Create an image data volume from a point cloud using gaussian splatter.
|
| >>> import pyvista as pv
|
| Load the Stanford Bunny mesh.
|
| >>> bunny = pv.examples.download_bunny()
|
| Apply Gaussian splatter to generate a volumetric representation.
|
| >>> volume = bunny.gaussian_splatting(radius=0.01)
|
| Threshold the volume to filter out low-density regions.
|
| >>> threshed = volume.threshold(0.05)
|
| Visualize the thresholded volume with semi-transparency and no scalar bar.
|
| >>> threshed.plot(opacity=0.5, show_scalar_bar=False)
|
| glyph(self: '_DataSetType', orient: 'bool | str' = True, scale: 'bool | str' = True, factor: 'float' = 1.0, geom: '_vtk.vtkDataSet | DataSet | Sequence[_vtk.vtkDataSet | DataSet] | None' = None, indices: 'VectorLike[int] | None' = None, tolerance: 'float | None' = None, absolute: 'bool' = False, clamping: 'bool' = False, rng: 'VectorLike[float] | None' = None, color_mode: "Literal['scale', 'scalar', 'vector']" = 'scale', progress_bar: 'bool' = False)
| Copy a geometric representation (called a glyph) to the input dataset.
|
| The glyph may be oriented along the input vectors, and it may
| be scaled according to scalar data or vector
| magnitude. Passing a table of glyphs to choose from based on
| scalars or vector magnitudes is also supported. The arrays
| used for ``orient`` and ``scale`` must be either both point data
| or both cell data.
|
| Parameters
| ----------
| orient : bool | str, default: True
| If ``True``, use the active vectors array to orient the glyphs.
| If string, the vector array to use to orient the glyphs.
| If ``False``, the glyphs will not be orientated.
|
| scale : bool | str | sequence[float], default: True
| If ``True``, use the active scalars to scale the glyphs.
| If string, the scalar array to use to scale the glyphs.
| If ``False``, the glyphs will not be scaled.
|
| factor : float, default: 1.0
| Scale factor applied to scaling array.
|
| geom : :vtk:`vtkDataSet` | tuple[:vtk:`vtkDataSet`], optional
| The geometry to use for the glyph. If missing, an arrow glyph
| is used. If a sequence, the datasets inside define a table of
| geometries to choose from based on scalars or vectors. In this
| case a sequence of numbers of the same length must be passed as
| ``indices``. The values of the range (see ``rng``) affect lookup
| in the table.
|
| .. note::
|
| The reference direction is relative to ``(1, 0, 0)`` on the
| provided geometry. That is, the provided geometry will be rotated
| from ``(1, 0, 0)`` to the direction of the ``orient`` vector at
| each point.
|
| indices : sequence[float], optional
| Specifies the index of each glyph in the table for lookup in case
| ``geom`` is a sequence. If given, must be the same length as
| ``geom``. If missing, a default value of ``range(len(geom))`` is
| used. Indices are interpreted in terms of the scalar range
| (see ``rng``). Ignored if ``geom`` has length 1.
|
| tolerance : float, optional
| Specify tolerance in terms of fraction of bounding box length.
| Float value is between 0 and 1. Default is None. If ``absolute``
| is ``True`` then the tolerance can be an absolute distance.
| If ``None``, points merging as a preprocessing step is disabled.
|
| absolute : bool, default: False
| Control if ``tolerance`` is an absolute distance or a fraction.
|
| clamping : bool, default: False
| Turn on/off clamping of "scalar" values to range.
|
| rng : sequence[float], optional
| Set the range of values to be considered by the filter
| when scalars values are provided.
|
| color_mode : str, optional, default: ``'scale'``
| If ``'scale'`` , color the glyphs by scale.
| If ``'scalar'`` , color the glyphs by scalar.
| If ``'vector'`` , color the glyphs by vector.
|
| .. versionadded:: 0.44
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Glyphs at either the cell centers or points.
|
| Examples
| --------
| Create arrow glyphs oriented by vectors and scaled by scalars.
| Factor parameter is used to reduce the size of the arrows.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_random_hills()
| >>> arrows = mesh.glyph(scale='Normals', orient='Normals', tolerance=0.05)
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(arrows, color='black')
| >>> actor = pl.add_mesh(
| ... mesh,
| ... scalars='Elevation',
| ... cmap='terrain',
| ... show_scalar_bar=False,
| ... )
| >>> pl.show()
|
| See :ref:`glyph_example`, :ref:`movie_glyphs_example`, and
| :ref:`glyph_table_example` for more examples using this filter.
|
| integrate_data(self: '_DataSetType', progress_bar: 'bool' = False)
| Integrate point and cell data.
|
| Area or volume is also provided in point data.
|
| This filter uses :vtk:`vtkIntegrateAttributes`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Mesh with 1 point and 1 vertex cell with integrated data in point
| and cell data.
|
| Examples
| --------
| Integrate data on a sphere mesh.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> sphere = pv.Sphere(theta_resolution=100, phi_resolution=100)
| >>> sphere.point_data['data'] = 2 * np.ones(sphere.n_points)
| >>> integrated = sphere.integrate_data()
|
| There is only 1 point and cell, so access the only value.
|
| >>> integrated['Area'][0]
| np.float64(3.14)
| >>> integrated['data'][0]
| np.float64(6.28)
|
| See the :ref:`integrate_data_example` for more examples using this filter.
|
| interpolate(self: '_DataSetType', target: 'DataSet | _vtk.vtkDataSet', sharpness: 'float' = 2.0, radius: 'float' = 1.0, strategy: "Literal['null_value', 'mask_points', 'closest_point']" = 'null_value', null_value: 'float' = 0.0, n_points: 'int | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, progress_bar: 'bool' = False)
| Interpolate values onto this mesh from a given dataset.
|
| The ``target`` dataset is typically a point cloud. Only point data from
| the ``target`` mesh will be interpolated onto points of this mesh. Whether
| preexisting point and cell data of this mesh are preserved in the
| output can be customized with the ``pass_point_data`` and
| ``pass_cell_data`` parameters.
|
| This uses a Gaussian interpolation kernel. Use the ``sharpness`` and
| ``radius`` parameters to adjust this kernel. You can also switch this
| kernel to use an N closest points approach.
|
| If the cell topology is more useful for interpolating, e.g. from a
| discretized FEM or CFD simulation, use
| :func:`pyvista.DataObjectFilters.sample` instead.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from. Point and cell arrays from
| this object are interpolated onto this mesh.
|
| sharpness : float, default: 2.0
| Set the sharpness (i.e., falloff) of the Gaussian kernel. As the
| sharpness increases the effects of distant points are reduced.
|
| radius : float, optional
| Specify the radius within which the basis points must lie.
|
| strategy : str, default: "null_value"
| Specify a strategy to use when encountering a "null" point during
| the interpolation process. Null points occur when the local
| neighborhood (of nearby points to interpolate from) is empty. If
| the strategy is set to ``'mask_points'``, then an output array is
| created that marks points as being valid (=1) or null (invalid =0)
| (and the NullValue is set as well). If the strategy is set to
| ``'null_value'``, then the output data value(s) are set to the
| ``null_value`` (specified in the output point data). Finally, the
| strategy ``'closest_point'`` is to simply use the closest point to
| perform the interpolation.
|
| null_value : float, default: 0.0
| Specify the null point value. When a null point is encountered
| then all components of each null tuple are set to this value.
|
| n_points : int, optional
| If given, specifies the number of the closest points used to form
| the interpolation basis. This will invalidate the radius argument
| in favor of an N closest points approach. This typically has poorer
| results.
|
| pass_cell_data : bool, default: True
| Preserve input mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve input mesh's original point data arrays.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Interpolated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.DataObjectFilters.sample
| Resample array data from one mesh onto another.
|
| :meth:`pyvista.ImageDataFilters.resample`
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Interpolate the values of 5 points onto a sample plane.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(7)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(plane, style='wireframe', line_width=5)
| >>> pl.show()
|
| See :ref:`interpolate_example`, :ref:`interpolate_sample_example`,
| and :ref:`resampling_example` for more examples using this filter.
|
| merge(self: '_DataSetType', grid: 'DataSet | _vtk.vtkDataSet | MultiBlock | Sequence[DataSet | _vtk.vtkDataSet] | None' = None, merge_points: 'bool' = True, tolerance: 'float' = 0.0, inplace: 'bool' = False, main_has_priority: 'bool | None' = None, progress_bar: 'bool' = False)
| Join one or many other grids to this grid.
|
| Can be used to merge points of adjacent cells when no grids
| are input.
|
| .. note::
| The ``+`` operator between two meshes uses this filter with
| the default parameters. When the target mesh is already a
| :class:`pyvista.UnstructuredGrid`, in-place merging via
| ``+=`` is similarly possible.
|
|
| .. warning::
|
| The merge order of this filter depends on the installed version
| of VTK. For example, if merging meshes ``a``, ``b``, and ``c``,
| the merged order is ``bca`` for VTK<9.5 and ``abc`` for VTK>=9.5.
| This may be a breaking change for some applications. If only
| merging two meshes, it may be possible to maintain `some` backwards
| compatibility by swapping the input order of the two meshes,
| though this may also affect the merged arrays and is therefore
| not fully backwards-compatible.
|
| Parameters
| ----------
| grid : :vtk:`vtkUnstructuredGrid` | list[:vtk:`vtkUnstructuredGrid`], optional
| Grids to merge to this grid.
|
| merge_points : bool, default: True
| Points in exactly the same location will be merged between
| the two meshes. Warning: this can leave degenerate point data.
|
| tolerance : float, default: 0.0
| The absolute tolerance to use to find coincident points when
| ``merge_points=True``.
|
| inplace : bool, default: False
| Updates grid inplace when True if the input type is an
| :class:`pyvista.UnstructuredGrid`.
|
| main_has_priority : bool, default: True
| When this parameter is true and merge_points is true,
| the arrays of the merging grids will be overwritten
| by the original main mesh.
|
| .. deprecated:: 0.46
|
| This keyword will be removed in a future version. The main mesh
| always has priority with VTK 9.5.0 or later.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Merged grid.
|
| Notes
| -----
| When two or more grids are joined, the type and name of each
| array must match or the arrays will be ignored and not
| included in the final merged mesh.
|
| Examples
| --------
| Merge three separate spheres into a single mesh.
|
| >>> import pyvista as pv
| >>> sphere_a = pv.Sphere(center=(1, 0, 0))
| >>> sphere_b = pv.Sphere(center=(0, 1, 0))
| >>> sphere_c = pv.Sphere(center=(0, 0, 1))
| >>> merged = sphere_a.merge([sphere_b, sphere_c])
| >>> merged.plot()
|
| merge_points(self: '_DataSetType', tolerance: 'float' = 0.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Merge duplicate points in this mesh.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| tolerance : float, optional
| Specify a tolerance to use when comparing points. Points within
| this tolerance will be merged.
|
| inplace : bool, default: False
| Overwrite the original mesh with the result. Only possible if the input
| is :class:`~pyvista.PolyData` or :class:`~pyvista.UnstructuredGrid`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : pyvista.PolyData | pyvista.UnstructuredGrid
| Mesh with merged points. PolyData is returned only if the input is PolyData.
|
| Examples
| --------
| Merge duplicate points in a mesh.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cylinder(resolution=4)
| >>> mesh.n_points
| 16
| >>> _ = mesh.merge_points(inplace=True)
| >>> mesh.n_points
| 8
|
| oriented_bounding_box(self: '_DataSetType', box_style: "Literal['frame', 'outline', 'face']" = 'face', *, axis_0_direction: 'VectorLike[float] | str | None' = None, axis_1_direction: 'VectorLike[float] | str | None' = None, axis_2_direction: 'VectorLike[float] | str | None' = None, frame_width: 'float' = 0.1, return_meta: 'bool' = False, as_composite: 'bool' = True)
| Return an oriented bounding box (OBB) for this dataset.
|
| By default, the bounding box is a :class:`~pyvista.MultiBlock` with six
| :class:`PolyData` comprising the faces of a cube. The blocks are named and
| ordered as ``('+X','-X','+Y','-Y','+Z','-Z')``.
|
| The box can optionally be styled as an outline or frame.
|
| .. note::
|
| The names of the blocks of the returned :class:`~pyvista.MultiBlock`
| correspond to the oriented box's local axes, not the global x-y-z axes.
| E.g. the normal of the ``'+X'`` face of the returned box has the same
| direction as the box's primary axis, and is not necessarily pointing in
| the +x direction ``(1, 0, 0)``.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| box_style : 'frame' | 'outline' | 'face', default: 'face'
| Choose the style of the box. If ``'face'`` (default), each face of the box
| is a single quad cell. If ``'outline'``, the edges of each face are returned
| as line cells. If ``'frame'``, the center portion of each face is removed to
| create a picture-frame style border with each face having four quads (one
| for each side of the frame). Use ``frame_width`` to control the size of the
| frame.
|
| axis_0_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's primary axis. If set, the first
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_1_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's secondary axis. If set, the second
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| axis_2_direction : VectorLike[float] | str, optional
| Approximate direction vector of this mesh's third axis. If set, the third
| axis in the returned ``axes`` metadata is flipped such that it best aligns
| with the specified vector. Can be a vector or string specifying the axis by
| name (e.g. ``'x'`` or ``'-x'``, etc.).
|
| frame_width : float, optional
| Set the width of the frame. Only has an effect if ``box_style`` is
| ``'frame'``. Values must be between ``0.0`` (minimal frame) and ``1.0``
| (large frame). The frame is scaled to ensure it has a constant width.
|
| return_meta : bool, default: False
| If ``True``, also returns the corner point and the three axes vectors
| defining the orientation of the box. The sign of the axes vectors can be
| controlled using the ``axis_#_direction`` arguments.
|
| as_composite : bool, default: True
| Return the box as a :class:`pyvista.MultiBlock` with six blocks: one for
| each face. Set this ``False`` to merge the output and return
| :class:`~pyvista.PolyData`.
|
| See Also
| --------
| bounding_box
| Similar filter for an axis-aligned bounding box (AABB).
|
| align_xyz
| Align a mesh to the world x-y-z axes. Used internally by this filter.
|
| pyvista.Plotter.add_bounding_box
| Add a bounding box to a scene.
|
| pyvista.CubeFacesSource
| Generate the faces of a cube. Used internally by this filter.
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.PolyData
| MultiBlock with six named cube faces when ``as_composite=True`` and
| PolyData otherwise.
|
| numpy.ndarray
| The box's corner point corresponding to the origin of its axes if
| ``return_meta=True``.
|
| numpy.ndarray
| The box's orthonormal axes vectors if ``return_meta=True``.
|
| Examples
| --------
| Create a bounding box for a dataset.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_oblique_cone()
| >>> box = mesh.oriented_bounding_box()
|
| Plot the mesh and its bounding box.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, color='red')
| >>> _ = pl.add_mesh(box, opacity=0.5)
| >>> pl.show()
|
| Return the metadata for the box.
|
| >>> box, point, axes = mesh.oriented_bounding_box('outline', return_meta=True)
|
| Use the metadata to plot the box's axes using :class:`~pyvista.AxesAssembly`.
| The assembly is aligned with the x-y-z axes and positioned at the origin by
| default. Create a transformation to scale, then rotate, then translate the
| assembly to the corner point of the box. The transpose of the axes is used
| as an inverted rotation matrix.
|
| >>> scale = box.length / 4
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(point)
| >>> axes_assembly = pv.AxesAssembly(user_matrix=transform.matrix)
|
| Plot the box and the axes.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| Note how the box's z-axis is pointing from the cone's tip to its base. If we
| want to flip this axis, we can "seed" its direction as the ``'-z'`` direction.
|
| >>> box, _, axes = mesh.oriented_bounding_box(
| ... 'outline', axis_2_direction='-z', return_meta=True
| ... )
| >>>
|
| Plot the box and axes again. This time, use :class:`~pyvista.AxesAssemblySymmetric`
| and position the axes in the center of the box.
|
| >>> center = pv.merge(box).points.mean(axis=0)
| >>> scale = box.length / 2
| >>> transform = pv.Transform().scale(scale).rotate(axes.T).translate(center)
| >>> axes_assembly = pv.AxesAssemblySymmetric(user_matrix=transform.matrix)
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh)
| >>> _ = pl.add_mesh(box, color='black', line_width=5)
| >>> _ = pl.add_actor(axes_assembly)
| >>> pl.show()
|
| outline(self: '_DataObjectType', generate_faces: 'bool' = False, progress_bar: 'bool' = False)
| Produce an outline of the full extent for the input dataset.
|
| Parameters
| ----------
| generate_faces : bool, default: False
| Generate solid faces for the box. This is disabled by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing an outline of the original dataset.
|
| See Also
| --------
| bounding_box
| Similar filter with additional options.
|
| Examples
| --------
| Generate and plot the outline of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> outline = sphere.outline()
| >>> pv.plot([sphere, outline], line_width=5)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| outline_corners(self: '_DataObjectType', factor: 'float' = 0.2, progress_bar: 'bool' = False)
| Produce an outline of the corners for the input dataset.
|
| Parameters
| ----------
| factor : float, default: 0.2
| Controls the relative size of the corners to the length of
| the corresponding bounds.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing outlined corners.
|
| Examples
| --------
| Generate and plot the corners of a sphere. This is
| effectively the ``(x, y, z)`` bounds of the mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> corners = sphere.outline_corners(factor=0.1)
| >>> pv.plot([sphere, corners], line_width=5)
|
| pack_labels(self: '_DataSetType', sort: 'bool' = False, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Renumber labeled data such that labels are contiguous.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)``. The
| output may optionally be sorted by label count.
|
| The output array ``'packed_labels'`` is added to the output by default,
| and is automatically set as the active scalars.
|
| See Also
| --------
| sort_labels
| Similar function with ``sort=True`` by default.
|
| Notes
| -----
| This filter uses :vtk:`vtkPackLabels` as the underlying method which
| requires VTK version 9.3 or higher. If :vtk:`vtkPackLabels` is not
| available, packing is done with ``NumPy`` instead which may be
| slower. For best performance, consider upgrading VTK.
|
| .. versionadded:: 0.43
|
| Parameters
| ----------
| sort : bool, default: False
| Whether to sort the output by label count in descending order
| (i.e. from largest to smallest).
|
| scalars : str, optional
| Name of scalars to pack. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the packed output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with packed labels.
|
| Examples
| --------
| Pack segmented image labels.
|
| Load non-contiguous image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show range of labels
|
| >>> image_labels.get_data_range()
| (np.uint8(0), np.uint8(29))
|
| Find 'gaps' in the labels
|
| >>> label_numbers = np.unique(image_labels.active_scalars)
| >>> label_max = np.max(label_numbers)
| >>> missing_labels = set(range(label_max)) - set(label_numbers)
| >>> len(missing_labels)
| 4
|
| Pack labels to remove gaps
|
| >>> packed_labels = image_labels.pack_labels()
|
| Show range of packed labels
|
| >>> packed_labels.get_data_range()
| (np.uint8(0), np.uint8(25))
|
| partition(self: '_DataSetType', n_partitions: 'int', generate_global_id: 'bool' = False, as_composite: 'bool' = True)
| Break down input dataset into a requested number of partitions.
|
| Cells on boundaries are uniquely assigned to each partition without duplication.
|
| It uses a kdtree implementation that builds balances the cell
| centers among a requested number of partitions. The current implementation
| only supports power-of-2 target partition. If a non-power of two value
| is specified for ``n_partitions``, then the load balancing simply
| uses the power-of-two greater than the requested value
|
| For more details, see :vtk:`vtkRedistributeDataSetFilter`.
|
| Parameters
| ----------
| n_partitions : int
| Specify the number of partitions to split the input dataset
| into. Current implementation results in a number of partitions equal
| to the power of 2 greater than or equal to the chosen value.
|
| generate_global_id : bool, default: False
| Generate global cell ids if ``None`` are present in the input. If
| global cell ids are present in the input then this flag is
| ignored.
|
| This is stored as ``"vtkGlobalCellIds"`` within the ``cell_data``
| of the output dataset(s).
|
| as_composite : bool, default: True
| Return the partitioned dataset as a :class:`pyvista.MultiBlock`.
|
| See Also
| --------
| split_bodies, extract_values
|
| Returns
| -------
| output : pyvista.MultiBlock | pyvista.UnstructuredGrid
| UnStructuredGrid if ``as_composite=False`` and MultiBlock when ``True``.
|
| Examples
| --------
| Partition a simple ImageData into a :class:`pyvista.MultiBlock`
| containing each partition.
|
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> out = grid.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, show_edges=True)
|
| Partition of the Stanford bunny.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny()
| >>> out = mesh.partition(4, as_composite=True)
| >>> out.plot(multi_colors=True, cpos='xy')
|
| plot_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide the circular arc into. Defaults
| to number of cells in the input mesh. Must be a positive
| integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the ``matplotlib`` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to the variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the ``matplotlib`` figure when ``True``.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> a = [mesh.bounds.x_min, mesh.bounds.y_min, mesh.bounds.z_max]
| >>> b = [mesh.bounds.x_max, mesh.bounds.y_min, mesh.bounds.z_min]
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc(
| ... a, b, center, resolution=1000, show=False
| ... ) # doctest:+SKIP
|
| plot_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a circular arc defined by a normal and polar vector and plot it.
|
| Plot the variables of interest in 2D where the X-axis is
| distance from Point A and the Y-axis is the variable of
| interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| center : sequence[int]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| scalars : str, optional
| The string name of the variable in the input dataset to
| probe. The active scalar is used by default.
|
| title : str, optional
| The string title of the `matplotlib` figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int), optional
| The size of the new figure.
|
| figure : bool, optional
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| :ref:`plot_over_circular_arc_example`
|
| Examples
| --------
| Sample a dataset along a high resolution circular arc and plot.
|
| >>> from pyvista import examples
| >>> mesh = examples.load_uniform()
| >>> normal = normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> angle = 90
| >>> center = [
| ... mesh.bounds.x_min,
| ... mesh.bounds.y_min,
| ... mesh.bounds.z_min,
| ... ]
| >>> mesh.plot_over_circular_arc_normal(
| ... center, polar=polar, angle=angle
| ... ) # doctest:+SKIP
|
| plot_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, scalars: 'str | None' = None, title: 'str | None' = None, ylabel: 'str | None' = None, figsize: 'tuple[int, int] | None' = None, figure: 'bool' = True, show: 'bool' = True, tolerance: 'float | None' = None, fname: 'str | None' = None, progress_bar: 'bool' = False) -> 'None'
| Sample a dataset along a high resolution line and plot.
|
| Plot the variables of interest in 2D using matplotlib where the
| X-axis is distance from Point A and the Y-axis is the variable
| of interest. Note that this filter returns ``None``.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| scalars : str, optional
| The string name of the variable in the input dataset to probe. The
| active scalar is used by default.
|
| title : str, optional
| The string title of the matplotlib figure.
|
| ylabel : str, optional
| The string label of the Y-axis. Defaults to variable name.
|
| figsize : tuple(int, int), optional
| The size of the new figure.
|
| figure : bool, default: True
| Flag on whether or not to create a new figure.
|
| show : bool, default: True
| Shows the matplotlib figure.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| fname : str, optional
| Save the figure this file name when set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Examples
| --------
| See the :ref:`plot_over_line_example` example.
|
| remove_nan_cells(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Remove cells whose scalar values are NaN.
|
| A cell is considered NaN if any of its associated scalar values are
| NaN. For point data, this means any cell containing a NaN point is
| dropped; for cell data, cells whose value is NaN are dropped.
|
| .. versionadded:: 0.48
|
| .. note::
| This filter is equivalent to calling
| :meth:`~pyvista.DataSetFilters.threshold` with ``all_scalars=True``
| and the default (auto-computed) value range, which uses
| :func:`numpy.nanmin` and :func:`numpy.nanmax` to exclude NaN
| values from the bounds. It is provided as a convenience because
| ``threshold`` defaults to ``preference='cell'`` and
| ``all_scalars=False``, which does not reliably remove NaN cells
| from point data.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to check for NaN values. Defaults to the
| currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either ``'point'``
| or ``'cell'``.
|
| component_mode : {'component', 'all', 'any'}, default: 'all'
| The method to satisfy the criteria for multicomponent scalars.
| ``'component'`` uses only the single component specified by
| ``component``. ``'all'`` drops a cell if any component is NaN.
| ``'any'`` keeps a cell as long as at least one component is
| finite.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets which
| component to check for NaN values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset with NaN cells removed.
|
| See Also
| --------
| threshold
| Threshold a dataset by value. ``remove_nan_cells`` is a thin
| wrapper around this filter.
| :meth:`~pyvista.DataSetFilters.extract_cells`
| Extract a subset of cells by index.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
|
| Examples
| --------
| Create a small grid with some NaN point values and remove the
| affected cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> grid = pv.ImageData(dimensions=(5, 5, 5))
| >>> values = np.arange(grid.n_points, dtype=float)
| >>> values[::7] = np.nan
| >>> grid.point_data['values'] = values
| >>> cleaned = grid.remove_nan_cells(scalars='values')
| >>> cleaned.n_cells < grid.n_cells
| True
| >>> bool(np.any(np.isnan(cleaned.point_data['values'])))
| False
|
| See :ref:`using_filters_example` for an end-to-end filter pipeline
| that begins with this filter.
|
| sample_over_circular_arc(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', center: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Arc containing the sampled data.
|
| Examples
| --------
| Sample a dataset over a circular arc and plot it.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> pointa = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> pointb = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_max,
| ... uniform.bounds.z_min,
| ... ]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_min,
| ... ]
| >>> sampled_arc = uniform.sample_over_circular_arc(
| ... pointa=pointa, pointb=pointb, center=center
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(sampled_arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_circular_arc_normal(self: '_DataSetType', center: 'VectorLike[float]', resolution: 'int | None' = None, normal: 'VectorLike[float] | None' = None, polar: 'VectorLike[float] | None' = None, angle: 'float | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset over a circular arc defined by a normal and polar vector and plot it.
|
| The number of segments composing the polyline is controlled by
| setting the object resolution.
|
| Parameters
| ----------
| center : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide circular arc into. Defaults to
| number of cells in the input mesh. Must be a positive
| integer.
|
| normal : sequence[float], optional
| The normal vector to the plane of the arc. By default it
| points in the positive Z direction.
|
| polar : sequence[float], optional
| Starting point of the arc in polar coordinates. By
| default it is the unit vector in the positive x direction.
|
| angle : float, optional
| Arc length (in degrees), beginning at the polar vector. The
| direction is counterclockwise. By default it is 360.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sampled Dataset.
|
| Examples
| --------
| Sample a dataset over a circular arc.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> uniform = examples.load_uniform()
| >>> uniform['height'] = uniform.points[:, 2]
| >>> normal = [0, 0, 1]
| >>> polar = [0, 9, 0]
| >>> center = [
| ... uniform.bounds.x_max,
| ... uniform.bounds.y_min,
| ... uniform.bounds.z_max,
| ... ]
| >>> arc = uniform.sample_over_circular_arc_normal(
| ... center=center, normal=normal, polar=polar
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(uniform, style='wireframe')
| >>> _ = pl.add_mesh(arc, line_width=10)
| >>> pl.show_axes()
| >>> pl.show()
|
| sample_over_line(self: '_DataSetType', pointa: 'VectorLike[float]', pointb: 'VectorLike[float]', resolution: 'int | None' = None, tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a line.
|
| Parameters
| ----------
| pointa : sequence[float]
| Location in ``[x, y, z]``.
|
| pointb : sequence[float]
| Location in ``[x, y, z]``.
|
| resolution : int, optional
| Number of pieces to divide line into. Defaults to number of cells
| in the input mesh. Must be a positive integer.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_line((-0.5, -0.5, 0), (0.5, 0.5, 0))
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| sample_over_multiple_lines(self: '_DataSetType', points: 'MatrixLike[float]', tolerance: 'float | None' = None, progress_bar: 'bool' = False)
| Sample a dataset onto a multiple lines.
|
| Parameters
| ----------
| points : array_like[float]
| List of points defining multiple lines.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is in a
| cell of the input. If not given, tolerance is automatically generated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Line object with sampled data from dataset.
|
| Examples
| --------
| Sample over a plane that is interpolating a point cloud.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> rng = np.random.default_rng(12)
| >>> point_cloud = rng.random((5, 3))
| >>> point_cloud[:, 2] = 0
| >>> point_cloud -= point_cloud.mean(0)
| >>> pdata = pv.PolyData(point_cloud)
| >>> pdata['values'] = rng.random(5)
| >>> plane = pv.Plane()
| >>> plane.clear_data()
| >>> plane = plane.interpolate(pdata, sharpness=3.5)
| >>> sample = plane.sample_over_multiple_lines(
| ... [
| ... [-0.5, -0.5, 0],
| ... [0.5, -0.5, 0],
| ... [0.5, 0.5, 0],
| ... ]
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(pdata, render_points_as_spheres=True, point_size=50)
| >>> _ = pl.add_mesh(sample, scalars='values', line_width=10)
| >>> _ = pl.add_mesh(plane, scalars='values', style='wireframe')
| >>> pl.show()
|
| select_enclosed_points(self: '_DataSetType', surface: 'PolyData', tolerance: 'float' = 0.001, inside_out: 'bool' = False, check_surface: 'bool' = True, progress_bar: 'bool' = False)
| Mark points as to whether they are inside a closed surface.
|
| This evaluates all the input points to determine whether they are in an
| enclosed surface. The filter produces a (0,1) mask
| (in the form of a :vtk:`vtkDataArray`) that indicates whether points are
| outside (mask value=0) or inside (mask value=1) a provided surface.
| (The name of the output :vtk:`vtkDataArray` is ``"SelectedPoints"``.)
|
| This filter produces and output data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. warning::
| The filter assumes that the surface is closed and
| manifold. A boolean flag can be set to force the filter to
| first check whether this is true. If ``False`` and not manifold,
| an error will be raised.
|
| .. deprecated:: 0.47
| This filter may be unreliable as it can erroneously mark outside points as inside.
| Use :meth:`select_interior_points` instead.
|
| Parameters
| ----------
| surface : pyvista.PolyData
| Set the surface to be used to test for containment. This must be a
| :class:`pyvista.PolyData` object.
|
| tolerance : float, default: 0.001
| The tolerance on the intersection. The tolerance is expressed as a
| fraction of the bounding box of the enclosing surface.
|
| inside_out : bool, default: False
| By default, points inside the surface are marked inside or sent
| to the output. If ``inside_out`` is ``True``, then the points
| outside the surface are marked inside.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed and manifold, a runtime
| error is raised.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing the ``point_data['SelectedPoints']`` array.
|
| See Also
| --------
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere
| surface mesh. Extract these points using the
| :func:`DataSetFilters.extract_points` filter and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_enclosed_points(sphere) # doctest:+SKIP
| >>> pts = plane.extract_points( # doctest:+SKIP
| ... selected['SelectedPoints'].view(bool),
| ... adjacent_cells=False,
| ... )
| >>> pl = pv.Plotter() # doctest:+SKIP
| >>> _ = pl.add_mesh(sphere, style='wireframe') # doctest:+SKIP
| >>> _ = pl.add_points(pts, color='r') # doctest:+SKIP
| >>> pl.show() # doctest:+SKIP
|
| select_interior_points(self: '_DataSetType', surface: 'pv.PolyData', *, method: '_SelectInteriorPointsOptions' = 'signed_distance', inside_out: 'bool' = False, check_surface: 'bool' = True, locator_tolerance: 'float | None' = None) -> '_DataSetType'
| Mark points from this mesh as inside or outside relative to a closed surface.
|
| Evaluate all of this mesh's points to determine if they are inside an enclosed surface.
| The filter produces a boolean point array named ``'selected_points'`` with ``True``
| values indicating points are inside, and ``False`` values indicating points are outside the
| provided surface.
|
| By default, the input surface is checked to ensure it is closed. Optionally, this check may
| be disabled.
|
| .. note::
| This filter generates a data array, but does not modify the
| input dataset. If you wish to extract cells or points, various
| threshold filters are available (i.e., threshold the output array).
|
| .. versionadded:: 0.47
|
| Parameters
| ----------
| surface : PolyData
| Surface used to test for containment. It should be a closed surface such that it has
| a defined "inside" and "outside".
|
| method : 'signed_distance' | 'cell_locator', default: 'signed_distance'
| Underlying method used to select points.
|
| - ``'signed_distance'``: Use :meth:`compute_implicit_distance` and select points based
| on the distance. Points with negative distance are inside, points with positive
| distance are outside.
| - ``'cell_locator'``: Use :vtk:`vtkSelectEnclosedPoints` to select points. This uses
| :vtk:`vtkStaticCellLocator` internally to spatially search for interior points. Use
| the ``locator_tolerance`` to control the search tolerance.
|
| .. note::
| The ``'signed_distance'`` method is generally slower, but is also more reliable
| for correctly identifying interior points.
|
| .. warning::
| The ``'cell_locator'`` option can erroneously mark outside points as inside.
|
| inside_out : bool, default: False
| By default, points inside the surface have value ``True``, and points outside
| have value ``False``. Set ``inside_out=True`` to invert this.
|
| check_surface : bool, default: True
| Specify whether to check the surface for closure. When ``True``, the
| algorithm first checks to see if the surface is closed and
| manifold. If the surface is not closed, a runtime error is raised.
|
| locator_tolerance : float, default: 0.001
| The tolerance on the intersection when using the ``'cell_locator'`` method. The
| tolerance is expressed as a fraction of the bounding box of the enclosing surface.
|
| Returns
| -------
| PolyData
| Mesh with a new ``'selected_points'`` :attr:`~pyvista.DataSet.point_data` array.
|
| See Also
| --------
| compute_implicit_distance, extract_points, extract_cells
| :ref:`extract_cells_inside_surface_example`
|
| Examples
| --------
| Determine which points on a plane are inside a manifold sphere surface mesh.
| Extract these points using the :func:`~DataSetFilters.extract_points` filter
| and then plot them.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> plane = pv.Plane()
| >>> selected = plane.select_interior_points(sphere)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| Select the outside points instead.
|
| >>> selected = plane.select_interior_points(sphere, inside_out=True)
| >>> pts = plane.extract_points(
| ... selected['selected_points'], include_cells=False
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(sphere, style='wireframe', line_width=3)
| >>> _ = pl.add_points(
| ... pts, color='r', point_size=15, render_points_as_spheres=True
| ... )
| >>> pl.show()
|
| separate_cells(self: '_DataSetType')
| Return a copy of the dataset with separated cells with no shared points.
|
| This method may be useful when datasets have scalars that need to be
| associated to each point of each cell rather than either each cell or
| just the points of the dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| UnstructuredGrid with isolated cells.
|
| Examples
| --------
| Load the example hex beam and separate its cells. This increases the
| total number of points in the dataset since points are no longer
| shared.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> grid.n_points
| 99
| >>> sep_grid = grid.separate_cells()
| >>> sep_grid.n_points
| 320
|
| See the :ref:`point_cell_scalars_example` for a more detailed example
| using this filter.
|
| shrink(self: '_DataSetType', shrink_factor: 'float' = 1.0, progress_bar: 'bool' = False)
| Shrink the individual faces of a mesh.
|
| This filter shrinks the individual faces of a mesh rather than
| scaling the entire mesh.
|
| Parameters
| ----------
| shrink_factor : float, default: 1.0
| Fraction of shrink for each cell. Default does not modify the
| faces.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with shrunk faces. Return type matches input.
|
| Examples
| --------
| First, plot the original cube.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the mesh with shrunk faces.
|
| >>> shrunk = mesh.shrink(0.5)
| >>> shrunk.clear_data() # cleans up plot
| >>> shrunk.plot(show_edges=True, line_width=5)
|
| sort_labels(self: '_DataSetType', scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', output_scalars: 'str | None' = None, progress_bar: 'bool' = False, inplace: 'bool' = False)
| Sort labeled data by number of points or cells.
|
| This filter renumbers scalar label data of any type with ``N`` labels
| such that the output labels are contiguous from ``[0, N)`` and
| sorted in descending order from largest to smallest (by label count).
| I.e., the largest label will have a value of ``0`` and the smallest
| label will have a value of ``N-1``.
|
| The filter is a convenience method for :func:`pyvista.DataSetFilters.pack_labels`
| with ``sort=True``.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to sort. Defaults to currently active scalars.
|
| preference : str, default: "point"
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``.
|
| output_scalars : str, None
| Name of the sorted output scalars. By default, the output is
| saved to ``'packed_labels'``.
|
| progress_bar : bool, default: False
| If ``True``, display a progress bar. Has no effect if VTK
| version is lower than 9.3.
|
| inplace : bool, default: False
| If ``True``, the mesh is updated in-place.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with sorted labels.
|
| Examples
| --------
| Sort segmented image labels.
|
| Load image labels
|
| >>> from pyvista import examples
| >>> import numpy as np
| >>> image_labels = examples.load_frog_tissues()
|
| Show label info for first four labels
|
| >>> label_number, label_size = np.unique(
| ... image_labels['MetaImage'], return_counts=True
| ... )
| >>> label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> label_size[:4]
| array([30805713, 35279, 19172, 38129])
|
| Sort labels
|
| >>> sorted_labels = image_labels.sort_labels()
|
| Show sorted label info for the four largest labels. Note
| the difference in label size after sorting.
|
| >>> sorted_label_number, sorted_label_size = np.unique(
| ... sorted_labels['packed_labels'], return_counts=True
| ... )
| >>> sorted_label_number[:4]
| pyvista_ndarray([0, 1, 2, 3], dtype=uint8)
| >>> sorted_label_size[:4]
| array([30805713, 438052, 204672, 133880])
|
| split_bodies(self: '_DataSetType', label: 'bool' = False, progress_bar: 'bool' = False)
| Find, label, and split connected bodies/volumes.
|
| This splits different connected bodies into blocks in a
| :class:`pyvista.MultiBlock` dataset.
|
| Parameters
| ----------
| label : bool, default: False
| A flag on whether to keep the ID arrays given by the
| ``connectivity`` filter.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| extract_values, partition, connectivity
|
| Returns
| -------
| pyvista.MultiBlock
| MultiBlock with a split bodies.
|
| Examples
| --------
| Split a uniform grid thresholded to be non-connected.
|
| >>> from pyvista import examples
| >>> dataset = examples.load_uniform()
| >>> _ = dataset.set_active_scalars('Spatial Cell Data')
| >>> threshed = dataset.threshold_percent([0.15, 0.50], invert=True)
| >>> bodies = threshed.split_bodies()
| >>> len(bodies)
| 2
|
| See :ref:`split_vol` for more examples using this filter.
|
| split_values(self: '_DataSetType', values: 'None | (float | VectorLike[float] | MatrixLike[float] | dict[str, float] | dict[float, str])' = None, *, ranges: 'None | (VectorLike[float] | MatrixLike[float] | dict[str, VectorLike[float]] | dict[tuple[float, float], str])' = None, scalars: 'str | None' = None, preference: "Literal['point', 'cell']" = 'point', component_mode: "Literal['any', 'all', 'multi'] | int" = 'all', **kwargs)
| Split mesh into separate sub-meshes using point or cell data.
|
| By default, this filter generates a separate mesh for each unique value in the
| data array and combines them as blocks in a :class:`~pyvista.MultiBlock`
| dataset. Optionally, specific values and/or ranges of values may be specified to
| control which values to split from the input.
|
| This filter is a convenience method for :meth:`~pyvista.DataSetFilters.extract_values`
| with ``split`` set to ``True`` by default. Refer to that filter's documentation
| for more details.
|
| .. versionadded:: 0.44
|
| Parameters
| ----------
| values : float | ArrayLike[float] | dict, optional
| Value(s) to extract. Can be a number, an iterable of numbers, or a dictionary
| with numeric entries. For ``dict`` inputs, either its keys or values may be
| numeric, and the other field must be strings. The numeric field is used as
| the input for this parameter, and if ``split`` is ``True``, the string field
| is used to set the block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| When extracting multi-component values with ``component_mode=multi``,
| each value is specified as a multi-component scalar. In this case,
| ``values`` can be a single vector or an array of row vectors.
|
| ranges : array_like | dict, optional
| Range(s) of values to extract. Can be a single range (i.e. a sequence of
| two numbers in the form ``[lower, upper]``), a sequence of ranges, or a
| dictionary with range entries. Any combination of ``values`` and ``ranges``
| may be specified together. The endpoints of the ranges are included in the
| extraction. Ranges cannot be set when ``component_mode=multi``.
|
| For ``dict`` inputs, either its keys or values may be numeric, and the other
| field must be strings. The numeric field is used as the input for this
| parameter, and if ``split`` is ``True``, the string field is used to set the
| block names of the returned :class:`~pyvista.MultiBlock`.
|
| .. note::
| Use ``+/-`` infinity to specify an unlimited bound, e.g.:
|
| - ``[0, float('inf')]`` to extract values greater than or equal to zero.
| - ``[float('-inf'), 0]`` to extract values less than or equal to zero.
|
| scalars : str, optional
| Name of scalars to extract with. Defaults to currently active scalars.
|
| preference : str, default: 'point'
| When ``scalars`` is specified, this is the preferred array type to search
| for in the dataset. Must be either ``'point'`` or ``'cell'``.
|
| component_mode : int | 'any' | 'all' | 'multi', default: 'all'
| Specify the component(s) to use when ``scalars`` is a multi-component array.
| Has no effect when the scalars have a single component. Must be one of:
|
| - number: specify the component number as a 0-indexed integer. The selected
| component must have the specified value(s).
| - ``'any'``: any single component can have the specified value(s).
| - ``'all'``: all individual components must have the specified values(s).
| - ``'multi'``: the entire multi-component item must have the specified value.
|
| **kwargs : dict, optional
| Additional keyword arguments passed to :meth:`~pyvista.DataSetFilters.extract_values`.
|
| See Also
| --------
| extract_values, split_bodies, partition
|
| Returns
| -------
| pyvista.MultiBlock
| Composite of split meshes with :class:`pyvista.UnstructuredGrid` blocks.
|
| Examples
| --------
| Load image with labeled regions.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> image = examples.load_channels()
| >>> np.unique(image.active_scalars)
| pyvista_ndarray([0, 1, 2, 3, 4])
|
| Split the image into its separate regions. Here, we also remove the first
| region for visualization.
|
| >>> multiblock = image.split_values()
| >>> _ = multiblock.pop(0) # Remove first region
|
| Plot the regions.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_composite(multiblock, multi_colors=True)
| >>> _ = pl.show_grid()
| >>> pl.show()
|
| Note that the block names are generic by default.
|
| >>> multiblock.keys()
| ['Block-01', 'Block-02', 'Block-03', 'Block-04']
|
| To name the output blocks, use a dictionary as input instead.
|
| Here, we also explicitly omit the region with ``0`` values from the input
| instead of removing it from the output.
|
| >>> labels = dict(region1=1, region2=2, region3=3, region4=4)
| >>>
| >>> multiblock = image.split_values(labels)
| >>> multiblock.keys()
| ['region1', 'region2', 'region3', 'region4']
|
| Plot the regions as separate meshes using the labels instead of plotting
| the MultiBlock directly.
|
| Clear scalar data so we can color each mesh using a single color
|
| >>> _ = [block.clear_data() for block in multiblock]
| >>>
| >>> pl = pv.Plotter()
| >>> pl.set_color_cycler('default')
| >>> _ = [
| ... pl.add_mesh(block, label=label)
| ... for block, label in zip(multiblock, labels)
| ... ]
| >>> _ = pl.add_legend()
| >>> pl.show()
|
| streamlines(self: '_DataSetType', vectors: 'str | None' = None, source_center: 'VectorLike[float] | None' = None, source_radius: 'float | None' = None, n_points: 'int' = 100, start_position: 'VectorLike[float] | None' = None, return_source: 'bool' = False, pointa: 'VectorLike[float] | None' = None, pointb: 'VectorLike[float] | None' = None, progress_bar: 'bool' = False, **kwargs)
| Integrate a vector field to generate streamlines.
|
| The default behavior uses a sphere as the source - set its
| location and radius via the ``source_center`` and
| ``source_radius`` keyword arguments. ``n_points`` defines the
| number of starting points on the sphere surface.
| Alternatively, a line source can be used by specifying
| ``pointa`` and ``pointb``. ``n_points`` again defines the
| number of points on the line.
|
| You can retrieve the source by specifying
| ``return_source=True``.
|
| Optional keyword parameters from
| :func:`pyvista.DataSetFilters.streamlines_from_source` can be
| used here to control the generation of streamlines.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| source_center : sequence[float], optional
| Length 3 tuple of floats defining the center of the source
| particles. Defaults to the center of the dataset.
|
| source_radius : float, optional
| Float radius of the source particle cloud. Defaults to one-tenth of
| the diagonal of the dataset's spatial extent.
|
| n_points : int, default: 100
| Number of particles present in source sphere or line.
|
| start_position : sequence[float], optional
| A single point. This will override the sphere point source.
|
| return_source : bool, default: False
| Return the source particles as :class:`pyvista.PolyData` as well as the
| streamlines. This will be the second value returned if ``True``.
|
| pointa, pointb : sequence[float], optional
| The coordinates of a start and end point for a line source. This
| will override the sphere and start_position point source.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| See :func:`pyvista.DataSetFilters.streamlines_from_source`.
|
| Returns
| -------
| streamlines : pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute values
| associated with each streamline are stored in the cell data, whereas
| those associated with streamline-points are stored in the point data.
|
| source : pyvista.PolyData
| The points of the source are the seed points for the streamlines.
| Only returned if ``return_source=True``.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| streamlines_evenly_spaced_2D(self: '_DataSetType', vectors: 'str | None' = None, start_position: 'VectorLike[float] | None' = None, integrator_type: 'Literal[2, 4]' = 2, step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', separating_distance: 'float' = 10.0, separating_distance_ratio: 'float' = 0.5, closed_loop_maximum_distance: 'float' = 0.5, loop_angle: 'float' = 20.0, minimum_number_of_loop_points: 'int' = 4, compute_vorticity: 'bool' = True, progress_bar: 'bool' = False)
| Generate evenly spaced streamlines on a 2D dataset.
|
| This filter only supports datasets that lie on the xy plane, i.e. ``z=0``.
| Particular care must be used to choose a `separating_distance`
| that do not result in too much memory being utilized. The
| default unit is cell length.
|
| Parameters
| ----------
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| start_position : sequence[float], optional
| The seed point for generating evenly spaced streamlines.
| If not supplied, a random position in the dataset is chosen.
|
| integrator_type : {2, 4}, default: 2
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta2. The recognized solvers are:
| RUNGE_KUTTA2 (``2``) and RUNGE_KUTTA4 (``4``).
|
| step_length : float, default: 0.5
| Constant Step size used for line integration, expressed in length
| units or cell length units (see ``step_unit`` parameter).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| interpolator_type : str, optional
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| separating_distance : float, default: 10
| The distance between streamlines expressed in ``step_unit``.
|
| separating_distance_ratio : float, default: 0.5
| Streamline integration is stopped if streamlines are closer than
| ``SeparatingDistance*SeparatingDistanceRatio`` to other streamlines.
|
| closed_loop_maximum_distance : float, default: 0.5
| The distance between points on a streamline to determine a
| closed loop.
|
| loop_angle : float, default: 20
| The maximum angle in degrees between points to determine a closed loop.
|
| minimum_number_of_loop_points : int, default: 4
| The minimum number of points before which a closed loop will
| be determined.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| This produces polylines as the output, with each cell
| (i.e., polyline) representing a streamline. The attribute
| values associated with each streamline are stored in the
| cell data, whereas those associated with streamline-points
| are stored in the point data.
|
| Examples
| --------
| Plot evenly spaced streamlines for cylinder in a crossflow.
| This dataset is a multiblock dataset, and the fluid velocity is in the
| first block.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cylinder_crossflow()
| >>> streams = mesh[0].streamlines_evenly_spaced_2D(
| ... start_position=(4, 0.1, 0.0),
| ... separating_distance=3,
| ... separating_distance_ratio=0.2,
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(streams.tube(radius=0.02), scalars='vorticity_mag')
| >>> pl.view_xy()
| >>> pl.show()
|
| See :ref:`streamlines_2D_example` for more examples using this filter.
|
| streamlines_from_source(self: '_DataSetType', source: '_vtk.vtkDataSet', vectors: 'str | None' = None, integrator_type: 'Literal[45, 2, 4]' = 45, integration_direction: "Literal['both', 'backward', 'forward']" = 'both', surface_streamlines: 'bool' = False, initial_step_length: 'float' = 0.5, step_unit: "Literal['cl', 'l']" = 'cl', min_step_length: 'float' = 0.01, max_step_length: 'float' = 1.0, max_steps: 'int' = 2000, terminal_speed: 'float' = 1e-12, max_error: 'float' = 1e-06, max_time: 'float | None' = None, compute_vorticity: 'bool' = True, rotation_scale: 'float' = 1.0, interpolator_type: "Literal['point', 'cell', 'p', 'c']" = 'point', progress_bar: 'bool' = False, max_length: 'float | None' = None)
| Generate streamlines of vectors from the points of a source mesh.
|
| The integration is performed using a specified integrator, by default
| Runge-Kutta45. This supports integration through any type of dataset.
| If the dataset contains 2D cells like polygons or triangles and the
| ``surface_streamlines`` parameter is used, the integration is constrained
| to lie on the surface defined by 2D cells.
|
| Parameters
| ----------
| source : pyvista.DataSet
| The points of the source provide the starting points of the
| streamlines. This will override both sphere and line sources.
|
| vectors : str, optional
| The string name of the active vector field to integrate across.
|
| integrator_type : {45, 2, 4}, default: 45
| The integrator type to be used for streamline generation.
| The default is Runge-Kutta45. The recognized solvers are:
| RUNGE_KUTTA2 (``2``), RUNGE_KUTTA4 (``4``), and RUNGE_KUTTA45
| (``45``). Options are ``2``, ``4``, or ``45``.
|
| integration_direction : str, default: "both"
| Specify whether the streamline is integrated in the upstream or
| downstream directions (or both). Options are ``'both'``,
| ``'backward'``, or ``'forward'``.
|
| surface_streamlines : bool, default: False
| Compute streamlines on a surface.
|
| initial_step_length : float, default: 0.5
| Initial step size used for line integration, expressed ib length
| unitsL or cell length units (see ``step_unit`` parameter).
| either the starting size for an adaptive integrator, e.g., RK45, or
| the constant / fixed size for non-adaptive ones, i.e., RK2 and RK4).
|
| step_unit : {'cl', 'l'}, default: "cl"
| Uniform integration step unit. The valid unit is now limited to
| only LENGTH_UNIT (``'l'``) and CELL_LENGTH_UNIT (``'cl'``).
| Default is CELL_LENGTH_UNIT.
|
| min_step_length : float, default: 0.01
| Minimum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_step_length : float, default: 1.0
| Maximum step size used for line integration, expressed in length or
| cell length units. Only valid for an adaptive integrator, e.g., RK45.
|
| max_steps : int, default: 2000
| Maximum number of steps for integrating a streamline.
|
| terminal_speed : float, default: 1e-12
| Terminal speed value, below which integration is terminated.
|
| max_error : float, 1e-6
| Maximum error tolerated throughout streamline integration.
|
| max_time : float, optional
| Specify the maximum length of a streamline expressed in physical length.
|
| .. deprecated:: 0.45.0
| ``max_time`` parameter is deprecated. Use ``max_length`` instead.
| It will be removed in v0.48. Default for ``max_time`` changed in v0.45.0.
|
| compute_vorticity : bool, default: True
| Vorticity computation at streamline points. Necessary for generating
| proper stream-ribbons using the :vtk:`vtkRibbonFilter`.
|
| rotation_scale : float, default: 1.0
| This can be used to scale the rate with which the streamribbons
| twist.
|
| interpolator_type : str, default: "point"
| Set the type of the velocity field interpolator to locate cells
| during streamline integration either by points or cells.
| The cell locator is more robust then the point locator. Options
| are ``'point'`` or ``'cell'`` (abbreviations of ``'p'`` and ``'c'``
| are also supported).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| max_length : float, optional
| Specify the maximum length of a streamline expressed in physical length.
| Default is 4 times the diagonal length of the bounding box of the ``source``
| dataset.
|
| Returns
| -------
| pyvista.PolyData
| Streamlines. This produces polylines as the output, with
| each cell (i.e., polyline) representing a streamline. The
| attribute values associated with each streamline are
| stored in the cell data, whereas those associated with
| streamline-points are stored in the point data.
|
| Examples
| --------
| See the :ref:`streamlines_example` example.
|
| surface_indices(self: '_DataSetType', progress_bar: 'bool' = False)
| Return the surface indices of a grid.
|
| .. versionchanged:: 0.47
| The underlying algorithm used to compute surface indices has changed.
| :vtk:`vtkGeometryFilter` is now used, previously it was :vtk:`vtkDataSetSurfaceFilter`.
|
| Parameters
| ----------
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| numpy.ndarray
| Indices of the surface points.
|
| Examples
| --------
| Return the first 10 surface indices of an UnstructuredGrid.
|
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> ind = grid.surface_indices()
| >>> ind[:10]
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| tessellate(self: '_DataSetType', max_n_subdivide: 'int' = 3, merge_points: 'bool' = True, progress_bar: 'bool' = False)
| Tessellate a mesh.
|
| This filter approximates nonlinear FEM-like elements with linear
| simplices. The output mesh will have geometry and any fields specified
| as attributes in the input mesh's point data. The attribute's copy
| flags are honored, except for normals.
|
| For more details see :vtk:`vtkTessellatorFilter`.
|
| Parameters
| ----------
| max_n_subdivide : int, default: 3
| Maximum number of subdivisions.
|
| merge_points : bool, default: True
| The adaptive tessellation will output vertices that are not shared among cells,
| even where they should be. This can be corrected to some extent.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset with tessellated mesh. Return type matches input.
|
| Examples
| --------
| First, plot the high order FEM-like elements.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> points = np.array(
| ... [
| ... [0.0, 0.0, 0.0],
| ... [2.0, 0.0, 0.0],
| ... [1.0, 2.0, 0.0],
| ... [1.0, 0.5, 0.0],
| ... [1.5, 1.5, 0.0],
| ... [0.5, 1.5, 0.0],
| ... ]
| ... )
| >>> cells = np.array([6, 0, 1, 2, 3, 4, 5])
| >>> cell_types = np.array([69])
| >>> mesh = pv.UnstructuredGrid(cells, cell_types, points)
| >>> mesh.plot(show_edges=True, line_width=5)
|
| Now, plot the tessellated mesh.
|
| >>> tessellated = mesh.tessellate()
| >>> tessellated.clear_data() # cleans up plot
| >>> tessellated.plot(show_edges=True, line_width=5)
|
| texture_map_to_plane(self: '_DataSetType', origin: 'VectorLike[float] | None' = None, point_u: 'VectorLike[float] | None' = None, point_v: 'VectorLike[float] | None' = None, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', use_bounds: 'bool' = False, progress_bar: 'bool' = False)
| Texture map this dataset to a user defined plane.
|
| This is often used to define a plane to texture map an image
| to this dataset. The plane defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| origin : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom left corner of the plane.
|
| point_u : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| bottom right corner of the plane.
|
| point_v : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| top left corner of the plane.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to this
| dataset. If ``False``, a new dataset is returned with the texture
| coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| use_bounds : bool, default: False
| Use the bounds to set the mapping plane by default (bottom plane
| of the bounding box).
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Original dataset with texture coordinates if
| ``inplace=True``, otherwise a copied dataset.
|
| Examples
| --------
| See :ref:`topo_map_example`
|
| texture_map_to_sphere(self: '_DataSetType', center: 'VectorLike[float] | None' = None, prevent_seam: 'bool' = True, inplace: 'bool' = False, name: 'str' = 'Texture Coordinates', progress_bar: 'bool' = False)
| Texture map this dataset to a user defined sphere.
|
| This is often used to define a sphere to texture map an image
| to this dataset. The sphere defines the spatial reference and
| extent of that image.
|
| Parameters
| ----------
| center : sequence[float], optional
| Length 3 iterable of floats defining the XYZ coordinates of the
| center of the sphere. If ``None``, this will be automatically
| calculated.
|
| prevent_seam : bool, default: True
| Control how the texture coordinates are generated. If
| set, the s-coordinate ranges from 0 to 1 and 1 to 0
| corresponding to the theta angle variation between 0 to
| 180 and 180 to 0 degrees. Otherwise, the s-coordinate
| ranges from 0 to 1 between 0 to 360 degrees.
|
| inplace : bool, default: False
| If ``True``, the new texture coordinates will be added to
| the dataset inplace. If ``False`` (default), a new dataset
| is returned with the texture coordinates.
|
| name : str, default: "Texture Coordinates"
| The string name to give the new texture coordinates if applying
| the filter inplace.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.DataSet
| Dataset containing the texture mapped to a sphere. Return
| type matches input.
|
| Examples
| --------
| See :ref:`texture_example`.
|
| threshold(self: '_DataSetType', value: 'float | VectorLike[float] | None' = None, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', all_scalars: 'bool' = False, component_mode: "Literal['component', 'all', 'any']" = 'all', component: 'int' = 0, method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Apply a :vtk:`vtkThreshold` filter to the input dataset.
|
| This filter will apply a :vtk:`vtkThreshold` filter to the input
| dataset and return the resulting object. This extracts cells
| where the scalar value in each cell satisfies the threshold
| criterion. If ``scalars`` is ``None``, the input's active
| scalars array is used.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Please also note the default ``preference`` choice for CELL data
| over POINT data. This is contrary to most other places in PyVista's
| API where the preference typically defaults to POINT data. We chose
| to prefer CELL data here so that if thresholding by a named array
| that exists for both the POINT and CELL data, this filter will
| default to the CELL data array while performing the CELL-wise
| operation.
|
| Parameters
| ----------
| value : float | sequence[float], optional
| Single value or ``(min, max)`` to be used for the data threshold. If
| a sequence, then length must be 2. If no value is specified, the
| non-NaN data range will be used to remove any NaN values.
| Please reference the ``method`` parameter for how single values
| are handled.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| all_scalars : bool, default: False
| If using scalars from point data, all
| points in a cell must satisfy the threshold when this
| value is ``True``. When ``False``, any point of the cell
| with a scalar value satisfying the threshold criterion
| will extract the cell. Has no effect when using cell data.
|
| component_mode : {'component', 'all', 'any'}
| The method to satisfy the criteria for the threshold of
| multicomponent scalars. 'component' (default)
| uses only the ``component``. 'all' requires all
| components to meet criteria. 'any' is when
| any component satisfies the criteria.
|
| component : int, default: 0
| When using ``component_mode='component'``, this sets
| which component to threshold on.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| See Also
| --------
| threshold_percent
| Threshold a dataset by a percentage of its scalar range.
| :meth:`~pyvista.DataSetFilters.remove_nan_cells`
| Convenience wrapper to remove cells containing NaN values.
| :meth:`~pyvista.DataSetFilters.extract_values`
| Threshold-like filter for extracting specific values and ranges.
| :meth:`~pyvista.ImageDataFilters.image_threshold`
| Similar method for thresholding :class:`~pyvista.ImageData`.
| :meth:`~pyvista.ImageDataFilters.select_values`
| Threshold-like filter for ``ImageData`` to keep some values and replace others.
| :ref:`compare_threshold_filters_example`
| This example showcases this filter and
| other similar ones.
|
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> import numpy as np
| >>> volume = np.zeros([10, 10, 10])
| >>> volume[:3] = 1
| >>> vol = pv.wrap(volume)
| >>> threshed = vol.threshold(0.1)
| >>> threshed
| UnstructuredGrid (...)
| N Cells: 243
| N Points: 400
| X Bounds: 0.000e+00, 3.000e+00
| Y Bounds: 0.000e+00, 9.000e+00
| Z Bounds: 0.000e+00, 9.000e+00
| N Arrays: 1
|
| Apply the threshold filter to Perlin noise. First generate
| the structured grid.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> grid.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=True,
| ... show_edges=False,
| ... )
|
| Next, apply the threshold.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(20, 20, 20)
| ... )
| >>> threshed = grid.threshold(value=0.02)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` and :ref:`image_representations_example`
| for more examples using this filter.
|
| threshold_percent(self: '_DataSetType', percent: 'float' = 0.5, scalars: 'str | None' = None, invert: 'bool' = False, continuous: 'bool' = False, preference: "Literal['point', 'cell']" = 'cell', method: "Literal['upper', 'lower']" = 'upper', progress_bar: 'bool' = False)
| Threshold the dataset by a percentage of its range on the active scalars array.
|
| .. warning::
| Thresholding is inherently a cell operation, even though it can use
| associated point data for determining whether to keep a cell. In
| other words, whether or not a given point is included after
| thresholding depends on whether that point is part of a cell that
| is kept after thresholding.
|
| Parameters
| ----------
| percent : float | sequence[float], optional
| The percentage in the range ``(0, 1)`` to threshold. If value is
| out of 0 to 1 range, then it will be divided by 100 and checked to
| be in that range.
|
| scalars : str, optional
| Name of scalars to threshold on. Defaults to currently active scalars.
|
| invert : bool, default: False
| Invert the threshold results. That is, cells that would have been
| in the output with this option off are excluded, while cells that
| would have been excluded from the output are included.
|
| continuous : bool, default: False
| When True, the continuous interval [minimum cell scalar,
| maximum cell scalar] will be used to intersect the threshold bound,
| rather than the set of discrete scalar values from the vertices.
|
| preference : str, default: 'cell'
| When ``scalars`` is specified, this is the preferred array
| type to search for in the dataset. Must be either
| ``'point'`` or ``'cell'``. Throughout PyVista, the preference
| is typically ``'point'`` but since the threshold filter is a
| cell-wise operation, we prefer cell data for thresholding
| operations.
|
| method : str, default: 'upper'
| Set the threshold method for single-values, defining which
| threshold bounds to use. If the ``value`` is a range, this
| parameter will be ignored, extracting data between the two
| values. For single values, ``'lower'`` will extract data
| lower than the ``value``. ``'upper'`` will extract data
| larger than the ``value``.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Dataset containing geometry that meets the threshold requirements.
|
| See Also
| --------
| threshold
| Threshold a dataset by value.
|
| Examples
| --------
| Apply a 50% threshold filter.
|
| >>> import pyvista as pv
| >>> noise = pv.perlin_noise(0.1, (2, 2, 2), (0, 0, 0))
| >>> grid = pv.sample_function(
| ... noise, bounds=[0, 1.0, -0, 1.0, 0, 1.0], dim=(30, 30, 30)
| ... )
| >>> threshed = grid.threshold_percent(0.5)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| Apply a 80% threshold filter.
|
| >>> threshed = grid.threshold_percent(0.8)
| >>> threshed.plot(
| ... cmap='gist_earth_r',
| ... show_scalar_bar=False,
| ... show_edges=True,
| ... )
|
| See :ref:`using_filters_example` for more examples using a similar filter.
|
| voxelize(self: 'DataSet', *, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'UnstructuredGrid'
| Voxelize mesh to UnstructuredGrid.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mesh fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the voxelized mesh. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mesh. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` is specified.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| UnstructuredGrid
| Voxelized unstructured grid of the original mesh.
|
| See Also
| --------
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxelized mesh with uniform spacing.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_bunny_coarse()
| >>> vox = mesh.voxelize(spacing=0.01)
| >>> vox.plot(show_edges=True)
|
| Create a voxelized mesh using non-uniform spacing.
|
| >>> vox = mesh.voxelize(spacing=(0.01, 0.005, 0.002))
| >>> vox.plot(show_edges=True)
|
| The bounds of the voxelized mesh always match the bounds of the input.
|
| >>> mesh.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09850578755140305)
|
| >>> vox.bounds
| BoundsTuple(x_min = -0.13155962526798248,
| x_max = 0.18016336858272552,
| y_min = -0.12048563361167908,
| y_max = 0.18769524991512299,
| z_min = -0.14300920069217682,
| z_max = 0.09650979936122894)
|
| Create a voxelized mesh with ``3 x 4 x 5`` cells. Since ``dimensions`` is the
| number of points, not cells, we need to add ``1`` to get the number of desired cells.
|
| >>> mesh = pv.Box()
| >>> cell_dimensions = np.array((3, 4, 5))
| >>> vox = mesh.voxelize(dimensions=cell_dimensions + 1)
| >>> vox.plot(show_edges=True)
|
| voxelize_binary_mask(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False)
| Voxelize mesh as a binary :class:`~pyvista.ImageData` mask.
|
| The binary mask is a point data array where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| This filter implements :vtk:`vtkPolyDataToImageStencil`. This
| algorithm operates as follows:
|
| * The algorithm iterates through the z-slice of the ``reference_volume``.
| * For each slice, it cuts the input :class:`~pyvista.PolyData` surface to create
| 2D polylines at that z position. It attempts to close any open polylines.
| * For each x position along the polylines, the corresponding y positions are
| determined.
| * For each slice, the grid points are labelled as foreground or background based
| on their xy coordinates.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output mask's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| mask fits the bounds of the input surface.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| .. versionadded:: 0.45.0
|
| .. note::
| For best results, ensure the input surface is a closed surface. The
| surface is considered closed if it has zero :attr:`~pyvista.PolyData.n_open_edges`.
|
| .. note::
| This filter returns voxels represented as point data, not
| :attr:`~pyvista.CellType.VOXEL` cells.
| This differs from :func:`~pyvista.voxelize` and :func:`~pyvista.voxelize_volume`
| which return meshes with voxel cells. See :ref:`image_representations_example`
| for examples demonstrating the difference.
|
| .. note::
| This filter does not discard internal surfaces, due, for instance, to
| intersecting meshes. Instead, the intersection will be considered as
| background which may produce unexpected results. See `Examples`.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated mask.
|
| foreground_value : int, default: 1
| Foreground value of the generated mask.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated mask image. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated mask image. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| ImageData
| Generated binary mask with a ``'mask'`` point data array. The data array
| has dtype :class:`numpy.uint8` if the foreground and background values are
| unsigned and less than 256.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_rectilinear
| Similar function that returns a :class:`~pyvista.RectilinearGrid` with cell data.
|
| pyvista.ImageDataFilters.contour_labels
| Filter that generates surface contours from labeled image data. Can be
| loosely considered as an inverse of this filter.
|
| pyvista.ImageDataFilters.points_to_cells
| Convert voxels represented as points to :attr:`~pyvista.CellType.VOXEL`
| cells.
|
| ImageData
| Class used to build custom ``reference_volume``.
|
| Examples
| --------
| Generate a binary mask from a coarse mesh.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> poly = examples.download_bunny_coarse()
| >>> mask = poly.voxelize_binary_mask()
|
| The mask is stored as :class:`~pyvista.ImageData` with point data scalars
| (zeros for background, ones for foreground).
|
| >>> mask
| ImageData (...)
| N Cells: 7056
| N Points: 8228
| X Bounds: -1.245e-01, 1.731e-01
| Y Bounds: -1.135e-01, 1.807e-01
| Z Bounds: -1.359e-01, 9.140e-02
| Dimensions: 22, 22, 17
| Spacing: 1.417e-02, 1.401e-02, 1.421e-02
| N Arrays: 1
|
| >>> np.unique(mask.point_data['mask'])
| pyvista_ndarray([0, 1], dtype=uint8)
|
| To visualize it as voxel cells, use :meth:`~pyvista.ImageDataFilters.points_to_cells`,
| then use :meth:`~pyvista.DataSetFilters.threshold` to extract the foreground.
|
| We also plot the voxel cells in blue and the input poly data in green for
| comparison.
|
| >>> def mask_and_polydata_plotter(mask, poly):
| ... voxel_cells = mask.points_to_cells().threshold(0.5)
| ...
| ... pl = pv.Plotter()
| ... _ = pl.add_mesh(voxel_cells, color='blue')
| ... _ = pl.add_mesh(poly, color='lime')
| ... pl.camera_position = 'xy'
| ... return pl
|
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| The spacing of the mask image is automatically adjusted to match the
| density of the input.
|
| Repeat the previous example with a finer mesh.
|
| >>> poly = examples.download_bunny()
| >>> mask = poly.voxelize_binary_mask()
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Control the spacing manually instead. Here, a very coarse spacing is used.
|
| >>> mask = poly.voxelize_binary_mask(spacing=(0.01, 0.04, 0.02))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Note that the spacing is only approximate. Check the mask's actual spacing.
|
| >>> mask.spacing
| (0.009731187485158443, 0.03858340159058571, 0.020112216472625732)
|
| The actual values may be greater or less than the specified values. Use
| ``rounding_func=np.floor`` to force all values to be greater.
|
| >>> mask = poly.voxelize_binary_mask(
| ... spacing=(0.01, 0.04, 0.02), rounding_func=np.floor
| ... )
| >>> mask.spacing
| (0.01037993331750234, 0.05144453545411428, 0.020112216472625732)
|
| Set the dimensions instead of the spacing.
|
| >>> mask = poly.voxelize_binary_mask(dimensions=(10, 20, 30))
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| >>> mask.dimensions
| (10, 20, 30)
|
| Create a mask using a reference volume. First generate polydata from
| an existing mask.
|
| >>> volume = examples.load_frog_tissues()
| >>> poly = volume.contour_labels()
|
| Now create the mask from the polydata using the volume as a reference.
|
| >>> mask = poly.voxelize_binary_mask(reference_volume=volume)
| >>> pl = mask_and_polydata_plotter(mask, poly)
| >>> pl.show()
|
| Visualize the effect of internal surfaces.
|
| >>> mesh = pv.Cylinder() + pv.Cylinder(center=(0, 0.75, 0))
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 100, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| Note how the intersection is excluded from the mask.
| To include the voxels delimited by internal surfaces in the foreground, the internal
| surfaces should be removed, for instance by applying a boolean union. Note that
| this operation in unreliable in VTK but may be performed with external tools such
| as `vtkbool <https://github.com/zippy84/vtkbool>`_.
|
| Alternatively, the intersecting parts of the mesh can be processed sequentially.
|
| >>> cylinder_1 = pv.Cylinder()
| >>> cylinder_2 = pv.Cylinder(center=(0, 0.75, 0))
|
| >>> reference_volume = pv.ImageData(
| ... dimensions=(1, 100, 50),
| ... spacing=(1, 0.0175, 0.02),
| ... origin=(0, -0.5 + 0.0175 / 2, -0.5 + 0.02 / 2),
| ... )
|
| >>> binary_mask_1 = cylinder_1.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
| >>> binary_mask_2 = cylinder_2.voxelize_binary_mask(
| ... reference_volume=reference_volume
| ... ).points_to_cells()
|
| >>> binary_mask_1['mask'] = binary_mask_1['mask'] | binary_mask_2['mask']
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask_1)
| >>> _ = pl.add_mesh(cylinder_1.slice(), color='red')
| >>> _ = pl.add_mesh(cylinder_2.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| When multiple internal surfaces are nested, they are successively treated as
| interfaces between background and foreground.
|
| >>> mesh = pv.Tube(radius=2) + pv.Tube(radius=3) + pv.Tube(radius=4)
| >>> binary_mask = mesh.voxelize_binary_mask(
| ... dimensions=(1, 50, 50)
| ... ).points_to_cells()
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(binary_mask)
| >>> _ = pl.add_mesh(mesh.slice(), color='red')
| >>> pl.show(cpos='yz')
|
| voxelize_rectilinear(self: 'DataSet', *, background_value: 'int | float' = 0, foreground_value: 'int | float' = 1, reference_volume: 'ImageData | None' = None, dimensions: 'VectorLike[int] | None' = None, spacing: 'float | VectorLike[float] | None' = None, rounding_func: 'Callable[[VectorLike[float]], VectorLike[int]] | None' = None, cell_length_percentile: 'float | None' = None, cell_length_sample_size: 'int | None' = None, progress_bar: 'bool' = False) -> 'RectilinearGrid'
| Voxelize mesh to create a RectilinearGrid voxel volume.
|
| The voxelization can be controlled in several ways:
|
| #. Specify the output geometry using a ``reference_volume``.
|
| #. Specify the ``spacing`` explicitly.
|
| #. Specify the ``dimensions`` explicitly.
|
| #. Specify the ``cell_length_percentile``. The spacing is estimated from the
| surface's cells using the specified percentile.
|
| Use ``reference_volume`` for full control of the output grid's geometry. For
| all other options, the geometry is implicitly defined such that the generated
| grid fits the bounds of the input mesh.
|
| If no inputs are provided, ``cell_length_percentile=0.1`` (10th percentile) is
| used by default to estimate the spacing. On systems with VTK < 9.2, the default
| spacing is set to ``1/100`` of the input mesh's length.
|
| A point data array ``mask`` is included where points inside and outside of the
| input surface are labelled with ``foreground_value`` and ``background_value``,
| respectively.
|
| .. versionadded:: 0.46
|
| .. note::
|
| This method is a wrapper around :meth:`voxelize_binary_mask`. See that
| method for additional information.
|
| Parameters
| ----------
| background_value : int, default: 0
| Background value of the generated grid.
|
| foreground_value : int, default: 1
| Foreground value of the generated grid.
|
| reference_volume : ImageData, optional
| Volume to use as a reference. The output will have the same ``dimensions``,
| ``origin``, ``spacing``, ``offset``, and ``direction_matrix`` as the reference.
|
| dimensions : VectorLike[int], optional
| Dimensions of the generated rectilinear grid. Set this value to control the
| dimensions explicitly. If unset, the dimensions are defined implicitly
| through other parameter. See summary and examples for details.
|
| .. note::
|
| Dimensions is the number of points along each axis, not cells. Set
| dimensions to ``N+1`` instead for ``N`` cells along each axis.
|
| spacing : float | VectorLike[float], optional
| Approximate spacing to use for the generated grid. Set this value
| to control the spacing explicitly. If unset, the spacing is defined
| implicitly through other parameters. See summary and examples for details.
|
| rounding_func : Callable[VectorLike[float], VectorLike[int]], optional
| Control how the dimensions are rounded to integers based on the provided or
| calculated ``spacing``. Should accept a length-3 vector containing the
| dimension values along the three directions and return a length-3 vector.
| :func:`numpy.round` is used by default.
|
| Rounding the dimensions implies rounding the actual spacing.
|
| Has no effect if ``reference_volume`` or ``dimensions`` are specified.
|
| cell_length_percentile : float, optional
| Cell length percentage ``p`` to use for computing the default ``spacing``.
| Default is ``0.1`` (10th percentile) and must be between ``0`` and ``1``.
| The ``p``-th percentile is computed from the cumulative distribution function
| (CDF) of lengths which are representative of the cell length scales present
| in the input. The CDF is computed by:
|
| #. Triangulating the input cells.
| #. Sampling a subset of up to ``cell_length_sample_size`` cells.
| #. Computing the distance between two random points in each cell.
| #. Inserting the distance into an ordered set to create the CDF.
|
| Has no effect if ``dimensions`` or ``reference_volume`` are specified.
|
| .. note::
| This option is only available for VTK 9.2 or greater.
|
| cell_length_sample_size : int, optional
| Number of samples to use for the cumulative distribution function (CDF)
| when using the ``cell_length_percentile`` option. ``100 000`` samples are
| used by default.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| RectilinearGrid
| RectilinearGrid as voxelized volume with discretized cells.
|
| See Also
| --------
| voxelize
| Similar function that returns a :class:`~pyvista.UnstructuredGrid` of
| :attr:`~pyvista.CellType.VOXEL` cells.
|
| voxelize_binary_mask
| Similar function that returns a :class:`~pyvista.ImageData` with point data.
|
| Examples
| --------
| Create a voxel volume of a nut. By default, the spacing is automatically
| estimated.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.examples.load_nut()
| >>> vox = mesh.voxelize_rectilinear()
|
| Plot the mesh together with its volume.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh=vox, show_edges=True)
| >>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1)
| >>> pl.show()
|
| Load a mesh of a cow.
|
| >>> mesh = examples.download_cow()
|
| Create an equal density voxel volume and plot the result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=0.15)
| >>> cpos = pv.CameraPosition(
| ... position=(15, 3, 15), focal_point=(0, 0, 0), viewup=(0, 0, 0)
| ... )
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True)
|
| Create a voxel volume from unequal density dimensions and plot result.
|
| >>> vox = mesh.voxelize_rectilinear(spacing=(0.15, 0.15, 0.5))
| >>> vox.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| Slice the unequal density voxel volume to view the ``mask`` scalars.
|
| >>> slices = vox.slice_orthogonal()
| >>> slices.plot(scalars='mask', show_edges=True, cpos=cpos)
|
| warp_by_scalar(self: '_DataSetType', scalars: 'str | None' = None, factor: 'float' = 1.0, normal: 'VectorLike[float] | None' = None, inplace: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Warp the dataset's points by a point data scalars array's values.
|
| This modifies point coordinates by moving points along point
| normals by the scalar amount times the scale factor.
|
| Parameters
| ----------
| scalars : str, optional
| Name of scalars to warp by. Defaults to currently active scalars.
|
| factor : float, default: 1.0
| A scaling factor to increase the scaling effect. Alias
| ``scale_factor`` also accepted - if present, overrides ``factor``.
|
| normal : sequence, optional
| User specified normal. If given, data normals will be
| ignored and the given normal will be used to project the
| warp.
|
| inplace : bool, default: False
| If ``True``, the points of the given dataset will be updated.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Accepts ``scale_factor`` instead of ``factor``.
|
| Returns
| -------
| pyvista.DataSet
| Warped Dataset. Return type matches input.
|
| Examples
| --------
| First, plot the unwarped mesh.
|
| >>> from pyvista import examples
| >>> mesh = examples.download_st_helens()
| >>> mesh.plot(cmap='gist_earth', show_scalar_bar=False)
|
| Now, warp the mesh by the ``'Elevation'`` scalars.
|
| >>> warped = mesh.warp_by_scalar('Elevation')
| >>> warped.plot(cmap='gist_earth', show_scalar_bar=False)
|
| See :ref:`compute_normals_example` for more examples using this filter.
|
| warp_by_vector(self: '_DataSetType', vectors: 'str | None' = None, factor: 'float' = 1.0, inplace: 'bool' = False, progress_bar: 'bool' = False)
| Warp the dataset's points by a point data vectors array's values.
|
| This modifies point coordinates by moving points along point
| vectors by the local vector times the scale factor.
|
| A classical application of this transform is to visualize
| eigenmodes in mechanics.
|
| Parameters
| ----------
| vectors : str, optional
| Name of vector to warp by. Defaults to currently active vector.
|
| factor : float, default: 1.0
| A scaling factor that multiplies the vectors to warp by. Can
| be used to enhance the warping effect.
|
| inplace : bool, default: False
| If ``True``, the function will update the mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| The warped mesh resulting from the operation.
|
| Examples
| --------
| Warp a sphere by vectors.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> sphere = examples.load_sphere_vectors()
| >>> warped = sphere.warp_by_vector()
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> actor = pl.add_text('Before warp')
| >>> actor = pl.add_mesh(sphere, color='white')
| >>> pl.subplot(0, 1)
| >>> actor = pl.add_text('After warp')
| >>> actor = pl.add_mesh(warped, color='white')
| >>> pl.show()
|
| See :ref:`warp_by_vector_example` and :ref:`warp_by_vector_eigenmodes_example` for
| more examples using this filter.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| bounds_size
| Return the size of each axis of the object's bounding box.
|
| .. versionadded:: 0.46
|
| Returns
| -------
| tuple[float, float, float]
| Size of each x-y-z axis.
|
| Examples
| --------
| Get the size of a cube. The cube has edge lengths af ``(1.0, 1.0, 1.0)``
| by default.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> mesh.bounds_size
| (1.0, 1.0, 1.0)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._BoundsSizeMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.filters.data_object.DataObjectFilters:
|
| cell_centers(self: '_DataSetOrMultiBlockType', vertex: 'bool' = True, pass_cell_data: 'bool' = True, progress_bar: 'bool' = False)
| Generate points at the center of the cells in this dataset.
|
| These points can be used for placing glyphs or vectors.
|
| Parameters
| ----------
| vertex : bool, default: True
| Enable or disable the generation of vertex cells.
|
| pass_cell_data : bool, default: True
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Polydata where the points are the cell centers of the
| original dataset.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Plane()
| >>> mesh.point_data.clear()
| >>> centers = mesh.cell_centers()
| >>> pl = pv.Plotter()
| >>> actor = pl.add_mesh(mesh, show_edges=True)
| >>> actor = pl.add_points(
| ... centers,
| ... render_points_as_spheres=True,
| ... color='red',
| ... point_size=20,
| ... )
| >>> pl.show()
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| cell_data_to_point_data(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| The method of transformation is based on averaging the data
| values of all cells using a particular point. Optionally, the
| input cell data can be passed through to the output as well.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| point_data_to_cell_data
| Similar transformation applied to point data.
| :meth:`~pyvista.ImageDataFilters.cells_to_points`
| Re-mesh :class:`~pyvista.ImageData` to a points-based representation.
|
| Examples
| --------
| First compute the face area of the example airplane mesh and
| show the cell values. This is to show discrete cell data.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(scalars='Area')
|
| These cell scalars can be applied to individual points to
| effectively smooth out the cell data onto the points.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf = surf.cell_data_to_point_data()
| >>> surf.plot(scalars='Area')
|
| cell_quality(self: '_DataSetOrMultiBlockType', quality_measure: "Literal['all', 'all_valid'] | _CellQualityLiteral | Sequence[_CellQualityLiteral]" = 'scaled_jacobian', *, null_value: 'float' = -1.0, progress_bar: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Compute a function of (geometric) quality for each cell of a mesh.
|
| The per-cell quality is added to the mesh's cell data, in an array with
| the same name as the quality measure. Cell types not supported by this
| filter or undefined quality of supported cell types will have an
| entry of ``-1``.
|
| See the :ref:`cell_quality_measures_table` below for all measures and the
| :class:`~pyvista.CellType` supported by each one.
| Defaults to computing the ``scaled_jacobian`` quality measure.
|
| .. _cell_quality_measures_table:
|
| .. include:: /api/core/cell_quality/cell_quality_measures_table.rst
|
| .. note::
|
| Refer to the `Verdict Library Reference Manual <https://github.com/sandialabs/verdict/raw/master/SAND2007-2853p.pdf>`_
| for low-level technical information about how each metric is computed.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| quality_measure : str | sequence[str], default: 'scaled_jacobian'
| The cell quality measure(s) to use. May be either:
|
| - A single measure or a sequence of measures listed in
| :ref:`cell_quality_measures_table`.
| - ``'all'`` to compute all measures.
| - ``'all_valid'`` to only keep quality measures that are valid for the mesh's
| cell type(s).
|
| A separate array is created for each measure.
|
| null_value : float, default: -1.0
| Float value for undefined quality. Undefined quality are qualities
| that could be addressed by this filter but is not well defined for
| the particular geometry of cell in question, e.g. a volume query
| for a triangle. Undefined quality will always be undefined.
| The default value is -1.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the computed mesh quality. Return type matches input.
| Cell data array(s) with the computed quality measure(s) are included.
|
| See Also
| --------
| :func:`~pyvista.cell_quality_info`
| Return information about a cell's quality measure, e.g. acceptable range.
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
|
| Examples
| --------
| Compute and plot the minimum angle of a sample sphere mesh.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=20, phi_resolution=20)
| >>> cqual = sphere.cell_quality('min_angle')
| >>> cqual.plot(show_edges=True)
|
| Quality measures like ``'volume'`` do not apply to 2D cells, and a null value
| of ``-1`` is returned.
|
| >>> qual = sphere.cell_quality('volume')
| >>> qual.get_data_range('volume')
| (np.float64(-1.0), np.float64(-1.0))
|
| Compute all valid quality measures for the sphere. These measures all return
| non-null values for :attr:`~pyvista.CellType.TRIANGLE` cells.
|
| >>> cqual = sphere.cell_quality('all_valid')
| >>> valid_measures = cqual.cell_data.keys()
| >>> valid_measures # doctest: +NORMALIZE_WHITESPACE
| ['area',
| 'aspect_frobenius',
| 'aspect_ratio',
| 'condition',
| 'distortion',
| 'max_angle',
| 'min_angle',
| 'radius_ratio',
| 'relative_size_squared',
| 'scaled_jacobian',
| 'shape',
| 'shape_and_size']
|
| See :ref:`mesh_quality_example` for more examples using this filter.
|
| cell_validator(self: '_DataSetOrMultiBlockType', *, tolerance: 'float | None' = None, planarity_tolerance: 'float | None' = None, size_tolerance: 'float | None' = None)
| Check the validity of each cell in this dataset.
|
| The status of each cell is encoded as a bit field cell data array ``'validity_state'``.
| The possible cell status values are:
|
|
| - :attr:`~pyvista.CellStatus.VALID`: Cell is valid and has no issues.
| - :attr:`~pyvista.CellStatus.COINCIDENT_POINTS`: Cell has duplicate coordinates or repeated use of the same connectivity entry.
| - :attr:`~pyvista.CellStatus.DEGENERATE_FACES`: Face(s) collapse to a line or a point through repeated collocated vertices.
| - :attr:`~pyvista.CellStatus.INTERSECTING_EDGES`: 2D cell has two edges that intersect.
| - :attr:`~pyvista.CellStatus.INTERSECTING_FACES`: 3D cell has two faces that intersect.
| - :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`: Cell references points outside the mesh's :class:`~pyvista.DataSet.points` array.
| - :attr:`~pyvista.CellStatus.INVERTED_FACES`: Cell face(s) do not point in the direction required by its :class:`~pyvista.CellType`.
| - :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`: 1D, 2D, or 3D cell has negative length, area, or volume, respectively.
| - :attr:`~pyvista.CellStatus.NON_CONTIGUOUS_EDGES`: 2D cell's perimeter edges are not contiguous.
| - :attr:`~pyvista.CellStatus.NON_CONVEX`: 2D or 3D cell is not convex.
| - :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`: Vertices for a face do not all lie in the same plane.
| - :attr:`~pyvista.CellStatus.WRONG_NUMBER_OF_POINTS`: Cell does not have the minimum number of points needed to describe it.
| - :attr:`~pyvista.CellStatus.ZERO_SIZE`: 1D, 2D, or 3D cell has zero length, area, or volume, respectively.
|
| Internally, :vtk:`vtkCellValidator` is first used to determine the initial status of each
| cell, then additional PyVista-exclusive checks are made and encoded in the validity state.
|
| For convenience, a field data array for each status is also appended:
|
| - Each field data array contains the indices of cells with the specified status.
| - The array names are lower-case versions of the status names above.
| - The ``VALID`` status is excluded from the field data, and an array named ``'invalid'``
| is included instead with cell ids for all invalid cells.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
| Include cell status checks for
| :attr:`~pyvista.CellStatus.INVALID_POINT_REFERENCES`,
| :attr:`~pyvista.CellStatus.ZERO_SIZE`,
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
|
| .. versionchanged:: 0.48
| The ``'validity_state'`` array is now a 64-bit integer array. Previously, it was a
| 16-bit array.
|
| .. versionadded:: 0.48
| Add tolerance keywords.
|
| Parameters
| ----------
| tolerance : float, default: 1.1920929e-07
| Value used for most floating point equality checks throughout the cell checking
| process, e.g. for checking coincident points or intersecting edges.
| The default value is the epsilon (``eps``) of ``float32`` dtype using
| :attr:`numpy.finfo`.
|
| .. note::
| This tolerance is independent of other tolerances.
|
| planarity_tolerance : float, default: 0.1
| Allowed relative distance a planar polyhedral cell face may protrude out of
| its plane compared to the largest distance between a face center and
| any of its corner points. Defaults to 0.1, meaning any polygonal cell whose face
| protrudes more than 10% of their radius out of the plane will be marked as invalid
| with status :attr:`~pyvista.CellStatus.NON_PLANAR_FACES`.
|
| Set this value to 0 to disable planarity checks for polyhedron cells.
|
| .. note::
| This tolerance only applies to :attr:`~pyvista.CellType.POLYHEDRON` cells, and
| is independent of other tolerances.
|
| size_tolerance : float, optional
| Value used for evaluating the
| :meth:`size <pyvista.DataObjectFilters.compute_cell_sizes>` of a cell. Cells with an
| absolute size less than or equal to this value are flagged as having
| :attr:`~pyvista.CellStatus.ZERO_SIZE`, and
| cells with a size less than this value are flagged as having
| :attr:`~pyvista.CellStatus.NEGATIVE_SIZE`.
| The default value is the epsilon (``eps``) of the mesh's points dtype using
| :attr:`numpy.finfo`.
|
| Setting this tolerance explicitly may be useful for marking small cells as invalid.
|
| .. note::
| This tolerance is independent of any other tolerances.
|
| Returns
| -------
| DataSet
| Dataset with field data of cell validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.validate_mesh`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Load a mesh with invalid cells.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.download_cow()
|
| Validate the cells and show the included arrays.
|
| >>> validated = mesh.cell_validator()
| >>> validated.array_names # doctest: +NORMALIZE_WHITESPACE
| ['validity_state',
| 'invalid',
| 'coincident_points',
| 'degenerate_faces',
| 'intersecting_edges',
| 'intersecting_faces',
| 'invalid_point_references',
| 'inverted_faces',
| 'negative_size',
| 'non_contiguous_edges',
| 'non_convex',
| 'non_planar_faces',
| 'wrong_number_of_points',
| 'zero_size']
|
| There are many arrays, but most are empty. Show unique scalar values.
|
| >>> validity_state = validated.cell_data['validity_state']
| >>> np.unique(validity_state)
| pyvista_ndarray([ 0, 16])
|
| The ``0`` cells are valid, and the cells with value ``16`` (i.e. hex ``0x10``) have a
| nonconvex state. We confirm this by printing the ``'non_convex'`` array, which shows there
| are three invalid cells.
|
| >>> validated.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Check the status of cells explicitly using :class:`~pyvista.CellStatus`. For checking
| if is a cell is valid, use equality ``==``.
|
| >>> validity_state[0] == pv.CellStatus.VALID
| np.True_
|
| >>> validity_state[1013] == pv.CellStatus.VALID
| np.False_
|
| Equality can also be used for checking specific status bits, but will only be ``True`` if
| the cell has exactly one status bit set.
|
| >>> validity_state[1013] == pv.CellStatus.NON_CONVEX
| np.True_
|
| In general, checking the status with bit operators should be preferred.
|
| >>> (
| ... validity_state[1013] & pv.CellStatus.NON_CONVEX
| ... ) == pv.CellStatus.NON_CONVEX
| np.True_
|
| We can also show all invalid cells. This matches the nonconvex ids, which confirms
| these are the only invalid cells.
|
| >>> validated.field_data['invalid']
| pyvista_ndarray([1013, 1532, 3250])
|
| Plot the cell states using :meth:`~pyvista.DataSetFilters.color_labels`. Orient the
| camera to show the underside of the cow where two of the invalid cells are located.
|
| >>> colored, color_map = validated.color_labels(
| ... scalars='validity_state', return_dict=True
| ... )
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(colored)
| >>> _ = pl.add_legend(color_map)
| >>> pl.view_xz()
| >>> pl.camera.zoom(2.5)
| >>> pl.show()
|
| Extract the invalid cells and plot them along with the original mesh as wireframe for
| context. Orient the camera to focus on the cow's left eye where the third invalid cell is
| located.
|
| >>> invalid_cells = mesh.extract_cells(validated['invalid'])
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh, style='wireframe', color='light gray')
| >>> _ = pl.add_mesh(invalid_cells, color='lime')
| >>> pl.camera_position = pv.CameraPosition(
| ... position=(5.1, 1.8, -4.9),
| ... focal_point=(4.7, 1.8, 0.38),
| ... viewup=(0.0, 1.0, 0.0),
| ... )
| >>> pl.show()
|
| clip(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, invert: 'bool' = True, value: 'float' = 0.0, inplace: 'bool' = False, return_clipped: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a plane by specifying the origin and normal.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the clip will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which the clip
| occurs. The default is the center of the dataset.
|
| invert : bool, default: True
| If ``True``, remove mesh parts in the ``normal`` direction from ``origin``.
| If ``False``, remove parts in the opposite direction.
|
| value : float, default: 0.0
| Set the clipping value along the normal direction.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| return_clipped : bool, default: False
| Return both unclipped and clipped parts of the dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for clipping. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| output : DataSet | MultiBlock | tuple[DataSet | MultiBlock, DataSet | MultiBlock]
| Clipped mesh when ``return_clipped=False`` or a tuple containing the
| unclipped and clipped meshes. Output mesh type matches input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Examples
| --------
| Clip a cube along the +X direction. ``triangulate`` is used as
| the cube is initially composed of quadrilateral faces and
| subdivide only works on triangles.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip()
| >>> clipped_cube.plot()
|
| Clip a cube in the +Z direction. This leaves half a cube
| below the XY plane.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip('z')
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_surface_example` for more examples using this filter.
|
| clip_box(self: '_DataSetOrMultiBlockType', bounds: 'float | VectorLike[float] | PolyData | None' = None, invert: 'bool' = True, factor: 'float' = 0.35, progress_bar: 'bool' = False, merge_points: 'bool' = True, crinkle: 'bool' = False)
| Clip a dataset by a bounding box defined by the bounds.
|
| If no bounds are given, a corner of the dataset bounds will be removed.
|
| Parameters
| ----------
| bounds : sequence[float], optional
| Length 6 sequence of floats: ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
| Length 3 sequence of floats: distances from the min coordinate of
| of the input mesh. Single float value: uniform distance from the
| min coordinate. Length 12 sequence of length 3 sequence of floats:
| a plane collection (normal, center, ...).
| :class:`pyvista.PolyData`: if a poly mesh is passed that represents
| a box with 6 faces that all form a standard box, then planes will
| be extracted from the box to define the clipping region.
|
| invert : bool, default: True
| Flag on whether to flip/invert the clip.
|
| factor : float, default: 0.35
| If bounds are not given this is the factor along each axis to
| extract the default box.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| merge_points : bool, default: True
| If ``True``, coinciding points of independently defined mesh
| elements will be merged.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the
| clip. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the original
| dataset.
|
| Returns
| -------
| pyvista.UnstructuredGrid
| Clipped dataset.
|
| Examples
| --------
| Clip a corner of a cube. The bounds of a cube are normally
| ``[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5]``, and this removes 1/8 of
| the cube's surface.
|
| >>> import pyvista as pv
| >>> cube = pv.Cube().triangulate().subdivide(3)
| >>> clipped_cube = cube.clip_box([0, 1, 0, 1, 0, 1])
| >>> clipped_cube.plot()
|
| See :ref:`clip_with_plane_box_example` for more examples using this filter.
|
| clip_slab(self: '_DataSetOrMultiBlockType', thickness: 'float', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, *, origin: 'VectorLike[float] | None' = None, invert: 'bool' = False, progress_bar: 'bool' = False, crinkle: 'bool' = False, plane: 'PolyData | None' = None)
| Clip a dataset by a slab of finite thickness around a plane.
|
| The slab is the volumetric region bounded by two parallel planes offset
| symmetrically by ``thickness / 2`` on each side of ``origin`` along
| ``normal``. This is sometimes called a "thick slice" because it yields
| a volumetric subset of the input rather than a 2D cross-section like
| :meth:`slice`.
|
| .. versionadded:: 0.48
|
| Parameters
| ----------
| thickness : float
| Total slab thickness measured perpendicular to ``normal``. Must be
| strictly positive. Half of ``thickness`` is applied on each side
| of ``origin``.
|
| normal : VectorLike[float] | str, optional
| Length-3 vector defining the slab's normal direction. Can also be
| specified as a string conventional direction such as ``'x'`` for
| ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc. The ``'x'``
| direction is used by default.
|
| origin : VectorLike[float], optional
| The center ``(x, y, z)`` coordinate of the slab. The default is
| the center of the dataset.
|
| invert : bool, default: False
| If ``False`` (the default), the slab interior is kept. If
| ``True``, the slab interior is removed and everything outside the
| two bounding planes is returned.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| crinkle : bool, default: False
| Crinkle the clip by extracting the entire cells along the slab
| boundaries. This adds the ``"cell_ids"`` array to the ``cell_data``
| attribute that tracks the original cell IDs of the input dataset.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for defining the slab orientation.
| Use this as an alternative to setting ``origin`` and ``normal``.
| The mean of the plane's normal vectors is used for the ``normal``
| parameter and the mean of the plane's points is used for the
| ``origin`` parameter.
|
| Returns
| -------
| pyvista.DataSet | pyvista.MultiBlock
| Clipped dataset. Output mesh type matches the input type for
| :class:`~pyvista.PointSet`, :class:`~pyvista.PolyData`, and
| :class:`~pyvista.MultiBlock`; otherwise the output type is
| :class:`~pyvista.UnstructuredGrid`.
|
| Raises
| ------
| ValueError
| If ``thickness`` is not strictly positive, or if ``normal`` is a
| zero vector.
|
| See Also
| --------
| clip
| clip_box
| slice
|
| Examples
| --------
| Extract a thick slab through the center of a sphere along the
| ``z``-axis.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slab = sphere.clip_slab(thickness=0.2, normal='z')
| >>> slab.plot(show_edges=True)
|
| compute_cell_sizes(self: '_DataSetOrMultiBlockType', length: 'bool' = True, area: 'bool' = True, volume: 'bool' = True, progress_bar: 'bool' = False, vertex_count: 'bool' = False)
| Compute sizes for 0D (vertex count), 1D (length), 2D (area) and 3D (volume) cells.
|
| Parameters
| ----------
| length : bool, default: True
| Specify whether or not to compute the length of 1D cells.
| This generates a ``'Length'`` cell data array.
|
| area : bool, default: True
| Specify whether or not to compute the area of 2D cells.
| This generates an ``'Area'`` cell data array.
|
| volume : bool, default: True
| Specify whether or not to compute the volume of 3D cells.
| This generates a ``'Volume'`` cell data array.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| vertex_count : bool, default: False
| Specify whether or not to compute sizes for vertex and polyvertex cells (0D cells).
| The computed value is the number of points in the cell.
| This generates a ``'VertexCount'`` cell data array.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with `cell_data` containing the ``"VertexCount"``,
| ``"Length"``, ``"Area"``, and ``"Volume"`` arrays if set
| in the parameters. Return type matches input.
|
| Notes
| -----
| If cells do not have a dimension (for example, the length of
| hexahedral cells), the corresponding array will be all zeros.
|
| Examples
| --------
| Compute the face area of the example airplane mesh.
|
| >>> from pyvista import examples
| >>> surf = examples.load_airplane()
| >>> surf = surf.compute_cell_sizes(length=False, volume=False)
| >>> surf.plot(show_edges=True, scalars='Area')
|
| Create a mesh with cells of various dimensions.
|
| >>> mesh_0D = examples.cells.Vertex()
| >>> mesh_1D = examples.cells.Line()
| >>> mesh_2D = examples.cells.Quadrilateral()
| >>> mesh_3D = examples.cells.Hexahedron()
| >>> mesh = mesh_0D + mesh_1D + mesh_2D + mesh_3D
|
| Compute all arrays and compare them.
|
| >>> sizes = mesh.compute_cell_sizes(vertex_count=True)
| >>> sizes['VertexCount']
| pyvista_ndarray([1., 0., 0., 0.])
|
| >>> sizes['Length']
| pyvista_ndarray([0., 1., 0., 0.])
|
| >>> sizes['Area']
| pyvista_ndarray([0., 0., 1., 0.])
|
| >>> sizes['Volume']
| pyvista_ndarray([0., 0., 0., 1.])
|
| ctp(self: '_DataSetOrMultiBlockType', pass_cell_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform cell data into point data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`cell_data_to_point_data`.
|
| Parameters
| ----------
| pass_cell_data : bool, default: False
| If enabled, pass the input cell data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_cell_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the cell data transformed into point data.
| Return type matches input.
|
| elevation(self: '_DataSetOrMultiBlockType', low_point: 'VectorLike[float] | None' = None, high_point: 'VectorLike[float] | None' = None, scalar_range: 'str | VectorLike[float] | None' = None, preference: "Literal['point', 'cell']" = 'point', set_active: 'bool' = True, progress_bar: 'bool' = False)
| Generate scalar values on a dataset.
|
| The scalar values lie within a user specified range, and are
| generated by computing a projection of each dataset point onto
| a line. The line can be oriented arbitrarily. A typical
| example is to generate scalars based on elevation or height
| above a plane.
|
| .. warning::
| This will create a scalars array named ``'Elevation'`` on the
| point data of the input dataset and overwrite the array
| named ``'Elevation'`` if present.
|
| Parameters
| ----------
| low_point : sequence[float], optional
| The low point of the projection line in 3D space. Default is bottom
| center of the dataset. Otherwise pass a length 3 sequence.
|
| high_point : sequence[float], optional
| The high point of the projection line in 3D space. Default is top
| center of the dataset. Otherwise pass a length 3 sequence.
|
| scalar_range : str | sequence[float], optional
| The scalar range to project to the low and high points on the line
| that will be mapped to the dataset. If None given, the values will
| be computed from the elevation (Z component) range between the
| high and low points. Min and max of a range can be given as a length
| 2 sequence. If ``str``, name of scalar array present in the
| dataset given, the valid range of that array will be used.
|
| preference : str, default: "point"
| When an array name is specified for ``scalar_range``, this is the
| preferred array type to search for in the dataset.
| Must be either ``'point'`` or ``'cell'``.
|
| set_active : bool, default: True
| A boolean flag on whether or not to set the new
| ``'Elevation'`` scalar as the active scalars array on the
| output dataset.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing elevation scalars in the
| ``"Elevation"`` array in ``point_data``.
|
| Examples
| --------
| Generate the "elevation" scalars for a sphere mesh. This is
| simply the height in Z from the XY plane.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> sphere_elv = sphere.elevation()
| >>> sphere_elv.plot(smooth_shading=True)
|
| Access the first 4 elevation scalars. This is a point-wise
| array containing the "elevation" of each point.
|
| >>> sphere_elv['Elevation'][:4] # doctest:+SKIP
| array([-0.5 , 0.5 , -0.49706897, -0.48831028], dtype=float32)
|
| See :ref:`using_filters_example` for more examples using this filter.
|
| extract_all_edges(self: '_DataSetOrMultiBlockType', use_all_points: 'bool | None' = None, clear_data: 'bool' = False, progress_bar: 'bool' = False)
| Extract all the internal/external edges of the dataset as PolyData.
|
| This produces a full wireframe representation of the input dataset.
|
| Parameters
| ----------
| use_all_points : bool, optional
| .. deprecated:: 0.44.0
| Parameter ``use_all_points`` is deprecated since VTK < 9.2 is no
| longer supported. This parameter has no effect and is always ``True``.
|
| clear_data : bool, default: False
| Clear any point, cell, or field data. This is useful
| if wanting to strictly extract the edges.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Edges extracted from the dataset.
|
| Examples
| --------
| Extract the edges of a sample unstructured grid and plot the edges.
| Note how it plots interior edges.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hex_beam = pv.read(examples.hexbeamfile)
| >>> edges = hex_beam.extract_all_edges()
| >>> edges.plot(line_width=5, color='k')
|
| See :ref:`cell_centers_example` for more examples using this filter.
|
| extract_surface(self: 'DataSet | MultiBlock', pass_pointid: 'bool' = True, pass_cellid: 'bool' = True, nonlinear_subdivision: 'int | None' = None, algorithm: '_ExtractSurfaceOptions | type[_SENTINEL]' = <class 'pyvista.core.filters.data_object._SENTINEL'>, progress_bar: 'bool' = False) -> 'PolyData'
| Extract surface geometry of the mesh as :class:`~pyvista.PolyData`.
|
| .. note::
| The underlying VTK algorithm can be selected for surface extraction.
| Using ``algorithm=None`` is recommended, and the appropriate algorithm
| will automatically be selected. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| .. versionchanged:: 0.47
| This filter is now generalized to also work with :class:`~pyvista.MultiBlock`.
|
| Parameters
| ----------
| pass_pointid : bool, default: True
| Adds a point array ``"vtkOriginalPointIds"`` that identifies which original points
| these surface points correspond to.
|
| pass_cellid : bool, default: True
| Adds a cell array ``"vtkOriginalCellIds"`` that identifies which original cells these
| surface cells correspond to.
|
| nonlinear_subdivision : int, default: 1
| Determines how many times the faces of non-linear cells are subdivided into linear
| faces. This option is only relevant when the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells, and cannot be used with
| the ``'geometry'`` algorithm.
|
| If ``0``, the output is the equivalent to its linear counterpart (and the midpoints
| determining the non-linear interpolation are discarded). If ``1`` (the default), the
| non-linear face is triangulated based on the midpoints. If greater than ``1``, the
| triangulated pieces are recursively subdivided to reach the desired subdivision.
| Setting the value to greater than ``1`` may cause some point data to not be passed even
| if no nonlinear faces exist.
|
| algorithm : 'auto' | 'geometry' | 'dataset_surface'
| VTK algorithm to use internally.
|
| - ``'geometry'``: use :vtk:`vtkGeometryFilter`.
| - ``'dataset_surface'``: use :vtk:`vtkDataSetSurfaceFilter`.
| - ``None``: The algorithm is automatically selected based on the input. For most
| cases, the ``'geometry'`` algorithm is selected by default. The ``'dataset_surface'``
| algorithm is only selected for cases where the input is an
| :class:`~pyvista.UnstructuredGrid` with non-linear cells.
|
| Using ``algorithm=None`` is recommended. The current default is ``'dataset_surface'``,
| but this will change to ``None`` in a future version.
|
| Both algorithms produce similar surfaces, but ``'geometry'`` is more performant.
| The ``'geometry'`` algorithm also
|
| - merges points by default,
| - tends to preserve the original mesh's point order and connectivity, and
| - generates closed surfaces where closed surfaces would normally be expected.
|
| See :ref:`compare_surface_extract_algorithms` for some examples of differences.
|
| In general, users should not need to select the specific algorithm. This option is
| mostly provided for backwards-compatibility or specific use cases. For example, if
| working with both linear and non-linear meshes, it may be preferable to use
| ``'dataset_surface'`` explicitly so that the generated surfaces may be more directly
| comparable.
|
| .. versionadded:: 0.47
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Surface mesh of the grid.
|
| Warnings
| --------
| Both ``"vtkOriginalPointIds"`` and ``"vtkOriginalCellIds"`` may be
| affected by other VTK operations. See `issue 1164
| <https://github.com/pyvista/pyvista/issues/1164>`_ for
| recommendations on tracking indices across operations.
|
| Examples
| --------
| Extract the surface of an UnstructuredGrid.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> grid = examples.load_hexbeam()
| >>> surf = grid.extract_surface(algorithm=None)
| >>> type(surf)
| <class 'pyvista.core.pointset.PolyData'>
| >>> surf['vtkOriginalPointIds']
| pyvista_ndarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
| 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
| 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
| 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
| 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
| 84, 85, 86, 87, 88, 89])
| >>> surf['vtkOriginalCellIds']
| pyvista_ndarray([ 0, 0, 0, 1, 1, 1, 3, 3, 3, 2, 2, 2, 36, 36,
| 36, 37, 37, 37, 39, 39, 39, 38, 38, 38, 5, 5, 9, 9,
| 13, 13, 17, 17, 21, 21, 25, 25, 29, 29, 33, 33, 4, 4,
| 8, 8, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32,
| 7, 7, 11, 11, 15, 15, 19, 19, 23, 23, 27, 27, 31, 31,
| 35, 35, 6, 6, 10, 10, 14, 14, 18, 18, 22, 22, 26, 26,
| 30, 30, 34, 34])
|
| Note that in the "vtkOriginalCellIds" array, the same original cells
| appears multiple times since this array represents the original cell of
| each surface cell extracted.
|
| See the :ref:`extract_surface_example` and :ref:`surface_smoothing_example`
| for more examples using this filter.
|
| flip_normal(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the normal.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| normal : VectorLike[float]
| Normal vector to flip about.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset flipped about its normal. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_normal([1.0, 1.0, 1.0], inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_x(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : sequence[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_x
| Concatenate a reflection about the x-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_x(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_y(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_y
| Concatenate a reflection about the y-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot()
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_y(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xy')
|
| flip_z(self: '_MeshType_co', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Flip mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to rotate about. Defaults to center of mesh at
| :attr:`~pyvista.DataSet.center`.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Flipped dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.flip_z
| Concatenate a reflection about the z-axis with a transformation.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> pl.subplot(0, 0)
| >>> pl.show_axes()
| >>> mesh1 = examples.download_teapot().rotate_x(90, inplace=False)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.subplot(0, 1)
| >>> pl.show_axes()
| >>> mesh2 = mesh1.flip_z(inplace=False)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show(cpos='xz')
|
| point_data_to_cell_data(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, categorical: 'bool' = False, progress_bar: 'bool' = False)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified within cells.
| Optionally, the input point data can be passed through to the output.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If ``True``, histograming is used to assign the
| cell data. Specifically, a histogram is populated for each cell
| from the scalar values at each point, and the bin with the most
| elements is selected. In case of a tie, the smaller value is selected.
|
| .. note::
|
| If the point data is continuous, values that are almost equal (within
| ``1e-6``) are merged into a single bin. Otherwise, for discrete data
| the number of bins equals the number of unique values.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| See Also
| --------
| cell_data_to_point_data
| Similar transformation applied to cell data.
| :meth:`~pyvista.ImageDataFilters.points_to_cells`
| Re-mesh :class:`~pyvista.ImageData` to a cells-based representation.
|
| Examples
| --------
| Color cells by their z coordinates. First, create point
| scalars based on z-coordinates of a sample sphere mesh. Then
| convert this point data to cell data. Use a low resolution
| sphere for emphasis of cell valued data.
|
| First, plot these values as point values to show the
| difference between point and cell data.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere.plot()
|
| Now, convert these values to cell data and then plot it.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
| >>> sphere['Z Coordinates'] = sphere.points[:, 2]
| >>> sphere = sphere.point_data_to_cell_data()
| >>> sphere.plot()
|
| ptc(self: '_DataSetOrMultiBlockType', pass_point_data: 'bool' = False, progress_bar: 'bool' = False, **kwargs)
| Transform point data into cell data.
|
| Point data are specified per node and cell data specified
| within cells. Optionally, the input point data can be passed
| through to the output.
|
| This method is an alias for :func:`point_data_to_cell_data`.
|
| Parameters
| ----------
| pass_point_data : bool, default: False
| If enabled, pass the input point data through to the output.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| **kwargs : dict, optional
| Deprecated keyword argument ``pass_point_arrays``.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset with the point data transformed into cell data.
| Return type matches input.
|
| reflect(self: '_MeshType_co', normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None, inplace: 'bool' = False, transform_all_input_vectors: 'bool' = False, progress_bar: 'bool' = False) -> '_MeshType_co'
| Reflect a dataset across a plane.
|
| Parameters
| ----------
| normal : array_like[float]
| Normal direction for reflection.
|
| point : array_like[float]
| Point which, along with ``normal``, defines the reflection
| plane. If not specified, this is the origin.
|
| inplace : bool, default: False
| When ``True``, modifies the dataset inplace.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise,
| only the points, normals and active vectors are transformed.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Reflected dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.reflect
| Concatenate a reflection matrix with a transformation.
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh = mesh.reflect((0, 0, 1), point=(0, 0, -100))
| >>> mesh.plot(show_edges=True)
|
| See the :ref:`reflect_example` for more examples using this filter.
|
| resize(self: '_MeshType_co', *, bounds: 'VectorLike[float] | None' = None, bounds_size: 'float | VectorLike[float] | None' = None, length: 'float | None' = None, center: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Resize the dataset's bounds.
|
| This filter rescales and translates the mesh to fit specified bounds. This is useful for
| normalizing datasets, changing units, or fitting datasets into specific coordinate ranges.
|
| It has three independent use cases:
|
| #. Use ``bounds`` to set the mesh's :attr:`~pyvista.DataSet.bounds` directly.
| #. Use ``bounds_size`` to set the mesh's ``bounds_size`` directly.
| #. Use ``length`` to set the mesh's diagonal ``length`` directly.
|
| By default, the ``bounds_size`` and ``length`` options resize the mesh so that its
| ``center`` is unchanged. Optionally, ``center`` may be set explicitly for these cases.
|
| .. versionadded:: 0.46
|
| See Also
| --------
| :meth:`scale`, :meth:`translate`
| Scale and/or translate a mesh. Used internally by :meth:`resize`.
|
| Parameters
| ----------
| bounds : VectorLike[float], optional
| Target :attr:`~pyvista.DataSet.bounds` for the resized dataset in the format
| ``[xmin, xmax, ymin, ymax, zmin, zmax]``. If provided, the dataset is scaled and
| translated to fit exactly within these bounds. Cannot be used together with
| ``bounds_size``, ``length``, or ``center``.
|
| bounds_size : float | VectorLike[float], optional
| Target size of the :attr:`~pyvista.DataSet.bounds` for the resized dataset. Use a
| single float to specify the size of all three axes, or a 3-element vector to set the
| size of each axis independently. Cannot be used together with ``bounds`` or ``length``.
|
| length : float, optional
| Target length of the :attr:`~pyvista.DataSet.bounds` for the resized dataset.
| Cannot be used together with ``bounds`` or ``bounds_size``.
|
| .. versionadded:: 0.47
|
| center : VectorLike[float], optional
| Center of the resized dataset in ``[x, y, z]``. By default, the mesh's
| :attr:`~pyvista.DataSet.center` is used. Only used when ``bounds_size`` or ``length``
| is specified.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed as part of the resize. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| If True, the dataset is modified in place. If False, a new dataset is returned.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Resized dataset. Return type matches input.
|
| Examples
| --------
| Load a mesh with asymmetric bounds and show them.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube(
| ... x_length=1.0, y_length=2.0, z_length=3.0, center=(1.0, 2.0, 3.0)
| ... )
| >>> mesh.bounds
| BoundsTuple(x_min = 0.5,
| x_max = 1.5,
| y_min = 1.0,
| y_max = 3.0,
| z_min = 1.5,
| z_max = 4.5)
|
| Resize it to fit specific bounds.
|
| >>> resized = mesh.resize(bounds=[-1, 2, -3, 4, -5, 6])
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 2.0,
| y_min = -3.0,
| y_max = 4.0,
| z_min = -5.0,
| z_max = 6.0)
|
| Resize the mesh so its diagonal length is ``4.0``. The mesh's center is unchanged.
|
| >>> resized = mesh.resize(length=4.0)
| >>> resized.length
| 4.0
| >>> resized.center
| (1.0, 2.0, 3.0)
|
| Resize the mesh so its size is ``4.0``. The mesh's center is again unchanged.
|
| >>> resized = mesh.resize(bounds_size=4.0)
| >>> resized.bounds_size
| (4.0, 4.0, 4.0)
| >>> resized.center
| (1.0, 2.0, 3.0)
| >>> resized.bounds
| BoundsTuple(x_min = -1.0,
| x_max = 3.0,
| y_min = 0.0,
| y_max = 4.0,
| z_min = 1.0,
| z_max = 5.0)
|
| Specify a different size for each axis and set the desired center.
|
| >>> resized = mesh.resize(bounds_size=(2.0, 1.0, 0.5), center=(1.0, 0.5, 0.25))
| >>> resized.bounds_size
| (2.0, 1.0, 0.5)
| >>> resized.center
| (1.0, 0.5, 0.25)
|
| Center the mesh at the origin and normalize its bounds to ``1.0``.
|
| >>> resized = mesh.resize(bounds_size=1.0, center=(0.0, 0.0, 0.0))
| >>> resized.bounds
| BoundsTuple(x_min = -0.5,
| x_max = 0.5,
| y_min = -0.5,
| y_max = 0.5,
| z_min = -0.5,
| z_max = 0.5)
|
| rotate(self: '_MeshType_co', rotation: 'RotationLike', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a point with a rotation matrix or ``Rotation`` object.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate
| Concatenate a rotation matrix with a transformation.
|
| Examples
| --------
| Define a rotation. Here, a 3x3 matrix is used which rotates about the z-axis by
| 60 degrees.
|
| >>> import pyvista as pv
| >>> rotation = [
| ... [0.5, -0.8660254, 0.0],
| ... [0.8660254, 0.5, 0.0],
| ... [0.0, 0.0, 1.0],
| ... ]
|
| Use the rotation to rotate a cone about its tip.
|
| >>> mesh = pv.Cone()
| >>> tip = (0.5, 0.0, 0.0)
| >>> rot = mesh.rotate(rotation, point=tip)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_vector(self: '_MeshType_co', vector: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about a vector.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle to rotate.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_vector
| Concatenate a rotation about a vector with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_vector((1, 1, 1), 30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_x(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the x-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_x
| Concatenate a rotation about the x-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the x-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_x(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_y(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the y-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_y
| Concatenate a rotation about the y-axis with a transformation.
|
| Examples
| --------
| Rotate a cube 30 degrees about the y-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_y(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| rotate_z(self: '_MeshType_co', angle: 'float', point: 'VectorLike[float] | None' = None, transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False) -> '_MeshType_co'
| Rotate mesh about the z-axis.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. Defaults to origin.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are
| transformed. Otherwise, only the points, normals and
| active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Rotated dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.rotate_z
| Concatenate a rotation about the z-axis with a transformation.
|
| Examples
| --------
| Rotate a mesh 30 degrees about the z-axis.
|
| >>> import pyvista as pv
| >>> mesh = pv.Cube()
| >>> rot = mesh.rotate_z(30, inplace=False)
|
| Plot the rotated mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(rot)
| >>> _ = pl.add_mesh(mesh, style='wireframe', line_width=3)
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| sample(self: '_DataSetOrMultiBlockType', target: 'DataSet | _vtk.vtkDataSet', tolerance: 'float | None' = None, pass_cell_data: 'bool' = True, pass_point_data: 'bool' = True, categorical: 'bool' = False, progress_bar: 'bool' = False, locator: "Literal['cell', 'cell_tree', 'obb_tree', 'static_cell'] | _vtk.vtkAbstractCellLocator | None" = 'static_cell', pass_field_data: 'bool' = True, mark_blank: 'bool' = True, snap_to_closest_point: 'bool' = False)
| Resample array data from a passed mesh onto this mesh.
|
| For `mesh1.sample(mesh2)`, the arrays from `mesh2` are sampled onto
| the points of `mesh1`. This function interpolates within an
| enclosing cell. This contrasts with
| :func:`pyvista.DataSetFilters.interpolate` that uses a distance
| weighting for nearby points. If there is cell topology, `sample` is
| usually preferred.
|
| The point data 'vtkValidPointMask' stores whether the point could be sampled
| with a value of 1 meaning successful sampling. And a value of 0 means
| unsuccessful.
|
| This uses :vtk:`vtkResampleWithDataSet`.
|
| Parameters
| ----------
| target : pyvista.DataSet
| The vtk data object to sample from - point and cell arrays from
| this object are sampled onto the nodes of the ``dataset`` mesh.
|
| tolerance : float, optional
| Tolerance used to compute whether a point in the source is
| in a cell of the input. If not given, tolerance is
| automatically generated.
|
| pass_cell_data : bool, default: True
| Preserve source mesh's original cell data arrays.
|
| pass_point_data : bool, default: True
| Preserve source mesh's original point data arrays.
|
| categorical : bool, default: False
| Control whether the source point data is to be treated as
| categorical. If the data is categorical, then the resultant data
| will be determined by a nearest neighbor interpolation scheme.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| locator : :vtk:`vtkAbstractCellLocator` or str or None, default: 'static_cell'
| Prototype cell locator to perform the ``FindCell()``
| operation. If ``None``, uses the DataSet ``FindCell`` method.
| Valid strings with mapping to vtk cell locators are
|
| * 'cell' - :vtk:`vtkCellLocator`
| * 'cell_tree' - :vtk:`vtkCellTreeLocator`
| * 'obb_tree' - :vtk:`vtkOBBTree`
| * 'static_cell' - :vtk:`vtkStaticCellLocator`
|
| pass_field_data : bool, default: True
| Preserve source mesh's original field data arrays.
|
| mark_blank : bool, default: True
| Whether to mark blank points and cells in "vtkGhostType".
|
| snap_to_closest_point : bool, default: False
| Whether to snap to cell with closest point if no cell is found. Useful
| when sampling from data with vertex cells. Requires vtk >=9.3.0.
|
| .. versionadded:: 0.43
|
| Returns
| -------
| output : DataSet | MultiBlock
| Dataset containing resampled data.
|
| See Also
| --------
| pyvista.DataSetFilters.interpolate
| Interpolate values from one mesh onto another.
|
| pyvista.ImageDataFilters.resample
| Resample image data to modify its dimensions and spacing.
|
| Examples
| --------
| Resample data from another dataset onto a sphere.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere(center=(4.5, 4.5, 4.5), radius=4.5)
| >>> data_to_probe = examples.load_uniform()
| >>> result = mesh.sample(data_to_probe)
| >>> result.plot(scalars='Spatial Point Data')
|
| If sampling from a set of points represented by a ``(n, 3)``
| shaped ``numpy.ndarray``, they need to be converted to a
| PyVista DataSet, e.g. :class:`pyvista.PolyData`, first.
|
| >>> import numpy as np
| >>> points = np.array([[1.5, 5.0, 6.2], [6.7, 4.2, 8.0]])
| >>> mesh = pv.PolyData(points)
| >>> result = mesh.sample(data_to_probe)
| >>> result['Spatial Point Data']
| pyvista_ndarray([ 46.5 , 225.12])
|
| See :ref:`resampling_example` and :ref:`interpolate_sample_example`
| for more examples using this filter.
|
| scale(self: '_MeshType_co', xyz: 'float | VectorLike[float]', transform_all_input_vectors: 'bool' = False, inplace: 'bool' = False, point: 'VectorLike[float] | None' = None) -> '_MeshType_co'
| Scale the mesh.
|
| .. note::
| See also the notes at :func:`transform` which is used by this filter
| under the hood.
|
| Parameters
| ----------
| xyz : float | VectorLike[float]
| A vector sequence defining the scale factors along x, y, and z. If
| a scalar, the same uniform scale is used along all three axes.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all input vectors are transformed. Otherwise, only
| the points, normals and active vectors are transformed.
|
| inplace : bool, default: False
| Updates mesh in-place.
|
| point : VectorLike[float], optional
| Point to scale from. Defaults to origin.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Scaled dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform.scale
| Concatenate a scale matrix with a transformation.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh1 = examples.download_teapot()
| >>> mesh2 = mesh1.scale([10.0, 10.0, 10.0], inplace=False)
|
| Plot meshes side-by-side
|
| >>> pl = pv.Plotter(shape=(1, 2))
| >>> # Create plot with unscaled mesh
| >>> pl.subplot(0, 0)
| >>> _ = pl.add_mesh(mesh1)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> # Create plot with scaled mesh
| >>> pl.subplot(0, 1)
| >>> _ = pl.add_mesh(mesh2)
| >>> pl.show_axes()
| >>> _ = pl.show_grid()
| >>> pl.show(cpos='xy')
|
| slice(self: '_DataSetOrMultiBlockType', normal: 'VectorLike[float] | _NormalsLiteral | None' = None, origin: 'VectorLike[float] | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False, plane: 'PolyData | None' = None)
| Slice a dataset by a plane at the specified origin and normal vector orientation.
|
| The origin and normal may be set explicitly or implicitly using a
| :func:`~pyvista.Plane`.
|
| If no parameters are given, the slice will occur in the center
| of the dataset along the x-axis.
|
| Parameters
| ----------
| normal : VectorLike[float] | str, optional
| Length-3 vector for the normal vector direction. Can also
| be specified as a string conventional direction such as
| ``'x'`` for ``(1, 0, 0)`` or ``'-x'`` for ``(-1, 0, 0)``, etc.
| The ``'x'`` direction is used by default.
|
| origin : sequence[float], optional
| The center ``(x, y, z)`` coordinate of the plane on which
| the slice occurs. The default is the center of the dataset.
|
| generate_triangles : bool, default: False
| If this is enabled (``False`` by default), the output will
| be triangles. Otherwise the output will be the intersection
| polygons.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| plane : PolyData, optional
| :func:`~pyvista.Plane` mesh to use for slicing. Use this as an
| alternative to setting ``origin`` and ``normal``. The mean of the
| plane's normal vectors is used for the ``normal`` parameter and
| the mean of the plane's points is used for the ``origin`` parameter.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice_implicit
| slice_orthogonal
| slice_along_axis
| slice_along_line
| clip_slab
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> sphere = pv.Sphere()
| >>> slice_x = sphere.slice(normal='x')
| >>> slice_y = sphere.slice(normal='y')
| >>> slice_z = sphere.slice(normal='z')
| >>> slices = slice_x + slice_y + slice_z
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_axis(self: '_DataSetOrMultiBlockType', n: 'int' = 5, axis: "Literal['x', 'y', 'z', 0, 1, 2]" = 'x', tolerance: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, bounds=None, center=None, progress_bar: 'bool' = False)
| Create many slices of the input dataset along a specified axis.
|
| Parameters
| ----------
| n : int, default: 5
| The number of slices to create.
|
| axis : str | int, default: 'x'
| The axis to generate the slices along. Perpendicular to the
| slices. Can be string name (``'x'``, ``'y'``, or ``'z'``) or
| axis index (``0``, ``1``, or ``2``).
|
| tolerance : float, optional
| The tolerance to the edge of the dataset bounds to create
| the slices. The ``n`` slices are placed equidistantly with
| an absolute padding of ``tolerance`` inside each side of the
| ``bounds`` along the specified axis. Defaults to 1% of the
| ``bounds`` along the specified axis.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| bounds : sequence[float], optional
| A 6-length sequence overriding the bounds of the mesh.
| The bounds along the specified axis define the extent
| where slices are taken.
|
| center : sequence[float], optional
| A 3-length sequence specifying the position of the line
| along which slices are taken. Defaults to the center of
| the mesh.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset in the X direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10)
| >>> slices.plot(line_width=5)
|
| Slice the random hills dataset in the Z direction.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_along_axis(n=10, axis='z')
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_along_line(self: '_DataSetOrMultiBlockType', line: 'pv.PolyData', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset using a polyline/spline as the path.
|
| This also works for lines generated with :func:`pyvista.Line`.
|
| Parameters
| ----------
| line : pyvista.PolyData
| A PolyData object containing one single PolyLine cell.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_orthogonal
| slice_along_axis
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset along a circular arc.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> center = np.array(hills.center)
| >>> point_a = center + np.array([5, 0, 0])
| >>> point_b = center + np.array([-5, 0, 0])
| >>> arc = pv.CircularArc(
| ... pointa=point_a, pointb=point_b, center=center, resolution=100
| ... )
| >>> line_slice = hills.slice_along_line(arc)
|
| Plot the circular arc and the hills mesh.
|
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(hills, smooth_shading=True, style='wireframe')
| >>> _ = pl.add_mesh(
| ... line_slice,
| ... line_width=10,
| ... render_lines_as_tubes=True,
| ... color='k',
| ... )
| >>> _ = pl.add_mesh(arc, line_width=10, color='grey')
| >>> pl.show()
|
| See :ref:`slice_example` for more examples using this filter.
|
| slice_implicit(self: '_DataSetOrMultiBlockType', implicit_function: '_vtk.vtkImplicitFunction', generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Slice a dataset by a VTK implicit function.
|
| Parameters
| ----------
| implicit_function : :vtk:`vtkImplicitFunction`
| Specify the implicit function to perform the cutting.
|
| generate_triangles : bool, default: False
| If ``True``, the output will be triangles. Otherwise the
| output will be the intersection polygons. If the cutting
| function is not a plane, the output will be 3D polygons,
| which might be nice to look at but hard to compute with
| downstream.
|
| .. note::
|
| PyVista's default is ``False``, which differs from
| :vtk:`vtkCutter`'s default of ``True``. The polygon
| codepath in :vtk:`vtkCutter` is significantly slower than
| the triangulation path: on a 1.3M-cell UnstructuredGrid
| the polygon path measures ~89 ms/op vs ~20 ms/op with
| ``generate_triangles=True`` (~5x slowdown). Pass
| ``generate_triangles=True`` for the fast path when the
| output cell shape is not load-bearing for your downstream
| code.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_orthogonal
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the surface of a sphere.
|
| >>> import pyvista as pv
| >>> import vtk
| >>> sphere = vtk.vtkSphere()
| >>> sphere.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(sphere)
| >>> slice.plot(show_edges=True, line_width=5)
|
| >>> cylinder = vtk.vtkCylinder()
| >>> cylinder.SetRadius(10)
| >>> mesh = pv.Wavelet()
| >>> slice = mesh.slice_implicit(cylinder)
| >>> slice.plot(show_edges=True, line_width=5)
|
| slice_orthogonal(self: '_DataSetOrMultiBlockType', x: 'float | None' = None, y: 'float | None' = None, z: 'float | None' = None, generate_triangles: 'bool' = False, contour: 'bool' = False, progress_bar: 'bool' = False)
| Create three orthogonal slices through the dataset on the three cartesian planes.
|
| Yields a MutliBlock dataset of the three slices.
|
| Parameters
| ----------
| x : float, optional
| The X location of the YZ slice.
|
| y : float, optional
| The Y location of the XZ slice.
|
| z : float, optional
| The Z location of the XY slice.
|
| generate_triangles : bool, default: False
| When ``True``, the output will be triangles. Otherwise the output
| will be the intersection polygons.
|
| .. note::
|
| PyVista's default differs from :vtk:`vtkCutter` (which
| defaults to ``True``). The polygon path is ~5x slower on
| UnstructuredGrids. Pass ``generate_triangles=True`` for
| the fast path. See :meth:`slice_implicit` for details.
|
| contour : bool, default: False
| If ``True``, apply a ``contour`` filter after slicing.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Sliced dataset.
|
| See Also
| --------
| slice
| slice_implicit
| slice_along_axis
| slice_along_line
| :meth:`~pyvista.ImageDataFilters.slice_index`
|
| Examples
| --------
| Slice the random hills dataset with three orthogonal planes.
|
| >>> from pyvista import examples
| >>> hills = examples.load_random_hills()
| >>> slices = hills.slice_orthogonal(contour=False)
| >>> slices.plot(line_width=5)
|
| See :ref:`slice_example` for more examples using this filter.
|
| transform(self: '_MeshType_co', trans: 'TransformLike', transform_all_input_vectors: 'bool' = False, inplace: 'bool | None' = None, progress_bar: 'bool' = False) -> '_MeshType_co'
| Transform this mesh with a 4x4 transform.
|
| .. warning::
| When using ``transform_all_input_vectors=True``, there is
| no distinction in VTK between vectors and arrays with
| three components. This may be an issue if you have scalar
| data with three components (e.g. RGB data). This will be
| improperly transformed as if it was vector data rather
| than scalar data. One possible (albeit ugly) workaround
| is to store the three components as separate scalar
| arrays.
|
| .. warning::
| In general, transformations give non-integer results. This
| method converts integer-typed vector data to float before
| performing the transformation. This applies to the points
| array, as well as any vector-valued data that is affected
| by the transformation. To prevent subtle bugs arising from
| in-place transformations truncating the result to integers,
| this conversion always applies to the input mesh.
|
| .. warning::
| Shear transformations are not supported for :class:`~pyvista.ImageData` or
| :class:`~pyvista.RectilinearGrid`, and rotations are not supported for
| :class:`~pyvista.RectilinearGrid`. If present, a ``ValueError`` is raised.
| To fully support these transformations, the input should be cast to
| :class:`~pyvista.StructuredGrid` `before` applying this filter.
|
| .. note::
| Transforming :class:`~pyvista.ImageData` modifies its
| :class:`~pyvista.ImageData.origin`,
| :class:`~pyvista.ImageData.spacing`, and
| :class:`~pyvista.ImageData.direction_matrix` properties.
|
| .. versionchanged:: 0.48.0
| The parameter ``inplace`` must be specified whereas it previously
| defaulted to ``True``.
|
| .. versionchanged:: 0.45.0
| Transforming :class:`~pyvista.ImageData` now returns ``ImageData``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.46.0
| Transforming :class:`~pyvista.RectilinearGrid` now returns ``RectilinearGrid``.
| Previously, :class:`~pyvista.StructuredGrid` was returned.
|
| .. versionchanged:: 0.47.0
| An error is now raised instead of a warning if a transformation cannot be
| applied.
|
| Parameters
| ----------
| trans : TransformLike
| Accepts a vtk transformation object or a 4x4
| transformation matrix.
|
| transform_all_input_vectors : bool, default: False
| When ``True``, all arrays with three components are
| transformed. Otherwise, only the normals and vectors are
| transformed. See the warning for more details.
|
| inplace : bool
| When ``True``, modifies the dataset inplace and returned dataset is
| the same dataset. When ``False`` a new transformed dataset is
| returned with the original unchanged. The value of this parameter
| must be explicitly set.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset. Return type matches input.
|
| See Also
| --------
| pyvista.Transform
| Describe linear transformations via a 4x4 matrix.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Translate a mesh by ``(50, 100, 200)``.
|
| >>> import numpy as np
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
|
| Here a 4x4 :class:`numpy.ndarray` is used, but any :class:`~pyvista.TransformLike`
| is accepted.
|
| >>> transform_matrix = np.array(
| ... [
| ... [1, 0, 0, 50],
| ... [0, 1, 0, 100],
| ... [0, 0, 1, 200],
| ... [0, 0, 0, 1],
| ... ]
| ... )
| >>> transformed = mesh.transform(transform_matrix, inplace=False)
| >>> transformed.plot(show_edges=True)
|
| triangulate(self: '_DataSetOrMultiBlockType', inplace: 'bool' = False, progress_bar: 'bool' = False)
| Return an all triangle mesh.
|
| More complex polygons will be broken down into triangles.
|
| Parameters
| ----------
| inplace : bool, default: False
| Updates mesh in-place.
|
| progress_bar : bool, default: False
| Display a progress bar to indicate progress.
|
| Returns
| -------
| pyvista.PolyData
| Mesh containing only triangles.
|
| Examples
| --------
| Generate a mesh with quadrilateral faces.
|
| >>> import pyvista as pv
| >>> plane = pv.Plane()
| >>> plane.point_data.clear()
| >>> plane.plot(show_edges=True, line_width=5)
|
| Convert it to an all triangle mesh.
|
| >>> mesh = plane.triangulate()
| >>> mesh.plot(show_edges=True, line_width=5)
|
| validate_mesh(self: '_DataSetOrMultiBlockType', validation_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, action: '_ActionOptions | None' = None, *, exclude_fields: 'MeshValidationFields | Sequence[MeshValidationFields] | None' = None, report_body: '_ReportBodyOptions' = 'message', **cell_validator_kwargs) -> '_MeshValidationReport[_DataSetOrMultiBlockType]'
| Validate this mesh's array data, points, and cells.
|
| This method returns a ``MeshValidationReport`` dataclass with information about the
| validity of a mesh. The dataclass contains validation fields which are specific to the
| mesh's data, points, and cells. By default, all validation fields below are checked and
| included in the report. Optionally, only a subset of fields may be requested, and a
| warning or error may be raised if the mesh is not valid.
|
| **Data validation fields**
|
| Fields specific to :attr:`~pyvista.DataSet.cell_data` and
| :attr:`~pyvista.DataSet.point_data` arrays.
|
| - ``cell_data_wrong_length``: Ensure the length of each cell data array matches
| :attr:`~pyvista.DataSet.n_cells`.
| - ``point_data_wrong_length``: Ensure the length of each point data array matches
| :attr:`~pyvista.DataSet.n_points`.
|
| .. note::
| When setting new arrays using PyVista's API, similar array validation checks are
| `already` implicitly performed. As such, these checks may be redundant in many cases.
| They are most useful for validating `newly` loaded or :func:`wrapped <pyvista.wrap>`
| meshes.
|
| **Point validation fields**
|
| - ``non_finite_points``: Ensure all points have real values (i.e. no ``NaN`` or ``Inf``).
| - ``unused_points``: Ensure all points are referenced by at least one cell.
|
| **Cell validation fields**
|
| - ``coincident_points``: Ensure there are no duplicate coordinates or repeated use of the
| same connectivity entry.
| - ``degenerate_faces``: Ensure faces do not collapse to a line or a point through repeated
| collocated vertices.
| - ``intersecting_edges``: Ensure two edges of a 2D cell do not intersect.
| - ``intersecting_faces``: Ensure two faces of a 3D cell do not intersect.
| - ``invalid_point_references``: Ensure all points referenced by cells are valid point ids
| that can be indexed by :class:`~pyvista.DataSet.points`.
| - ``inverted_faces``: Ensure the faces of a cell point in the direction required by its
| :class:`~pyvista.CellType`.
| - ``negative_size``: Ensure 1D, 2D, and 3D cells have positive length, area, and volume,
| respectively.
| - ``non_contiguous_edges``: Ensure edges around the perimeter of a 2D cell are contiguous.
| - ``non_convex``: Ensure all 2D and 3D cells are convex.
| - ``non_planar_faces``: Ensure vertices for a face all lie in the same plane.
| - ``wrong_number_of_points``: Ensure each cell has the minimum number of points needed to
| describe it.
| - ``zero_size``: Ensure 1D, 2D, and 3D cells have non-zero length, area, and volume,
| respectively.
|
| .. note::
| All cell fields are computed using :meth:`~pyvista.DataObjectFilters.cell_validator`,
| and the field names correspond to :class:`~pyvista.CellStatus` names.
|
| For each field, its value is:
|
| - ``None`` if the field is omitted from the report,
| - an empty list ``[]`` if the field is included but there is no issue to report for it, or
| - a list of invalid items (e.g. invalid array names or cell/point ids).
|
| In addition to the validation fields above, the report includes properties for
| convenience:
|
| - ``is_valid``: evaluates to ``True`` when all fields are ``None`` or empty.
| - ``invalid_fields``: tuple of validation field names where problems were detected.
| - ``mesh``: a shallow copy of the validated mesh. If any cell fields are included which
| are computed by :meth:`~pyvista.DataObjectFilters.cell_validator`, this mesh includes the
| output from that filter.
| - ``message``: message string generated by the report. The message contains a compact
| summary of any problems detected, and is formatted for printing to console. This is the
| message used when the ``action`` keyword is set for emitting warnings or raising errors.
| This value is ``None`` if the mesh is valid.
|
| Validating composite :class:`~pyvista.MultiBlock` is also supported. In this case, all
| mesh blocks are validated separately and the results are aggregated and reported per-block.
|
| .. versionadded:: 0.47
|
| .. versionchanged:: 0.48
|
| - Include cell fields ``zero_size`` and ``negative_size``.
| - Report fields are now sorted in alphabetical order. Point fields are also reported
| before cell fields.
| - The body of the report now shows the error message instead of validation fields,
| i.e. the default value of ``report_body`` is now ``'message'`` instead of
| ``'fields'``.
|
| Parameters
| ----------
| validation_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to include in the validation report. All data, point, and cell
| fields are included by default. Specify individual fields by name, or use group name(s)
| to include multiple related validation fields:
|
| - ``'data'`` to include all data fields
| - ``'points'`` to include all point fields
| - ``'cells'`` to include all cell fields
| - ``'memory_safe'`` to include all fields that, if invalid, may cause a segmentation
| fault and crash Python. This option includes ``cell_data_wrong_length``,
| ``point_data_wrong_length``, and ``invalid_point_references``.
|
| Fields that are excluded from the report will have a value of ``None``.
|
| action : 'warn' | 'error', optional
| Issue a warning or raise an error if the mesh is not valid for the specified fields.
| By default, no action is taken.
|
| exclude_fields : MeshValidationFields | sequence[MeshValidationFields], optional
| Select which field(s) to exclude from the validation report. This is similar to
| using ``validation_fields``, but is subtractive instead of additive. All data, point,
| and cell fields are `included` by default, and no fields are excluded.
|
| .. versionadded:: 0.48
|
| report_body : 'fields' | 'message', optional
| Contents to show in the body of the report.
|
| - ``'fields'``: Show all validated fields. A list of any/all invalid ids are shown.
| - ``'message'``: Show the error message as the body of the report (if any).
|
| Using ``'fields'`` as the body is more explicit in terms of showing `which` fields
| have been validated. Using ``'message'`` is typically visually more compact though,
| and the message includes additional cell type-specific information.
|
| .. versionadded:: 0.48
|
| cell_validator_kwargs
| Keyword arguments passed to :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| .. versionadded:: 0.48
|
| Returns
| -------
| MeshValidationReport
| Report dataclass with information about mesh validity.
|
| See Also
| --------
| :meth:`~pyvista.DataObjectFilters.cell_validator`
| :meth:`~pyvista.DataObjectFilters.cell_quality`
| :meth:`~pyvista.UnstructuredGridFilters.remove_unused_points`
| :ref:`mesh_validation_example`
|
| Examples
| --------
| Create a :func:`~pyvista.Sphere` and check if it's a valid mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = pv.Sphere()
| >>> report = mesh.validate_mesh()
| >>> report.is_valid
| True
|
| Print the report. By default, the report is relatively minimal, and only includes
| an error message if the mesh is invalid.
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
|
| Use ``report_body`` to explicitly show the validated fields.
|
| >>> report = mesh.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 842
| N Cells : 1680
| Cell types : {TRIANGLE}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Invalid point ids:
| Non-finite points : []
| Unused points : []
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex : []
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Load a mesh with invalid cells, e.g. :func:`~pyvista.examples.downloads.download_cow`
| and validate it. Use ``'cells'`` to only validate the cells specifically.
|
| >>> mesh = examples.download_cow()
| >>> report = mesh.validate_mesh('cells', report_body='fields')
|
| Alternatively, use ``exclude_fields`` to `remove` fields from the report instead.
| For example, excluding ``data`` and ``points`` is the same as including ``cells``.
|
| >>> report_excluded = mesh.validate_mesh(exclude_fields=['data', 'points'])
| >>> report_excluded == report
| True
|
| Show the report. Note that only cell validation fields are reported (array and point
| fields are omitted).
|
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Invalid cell ids:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (3) : [1013, 1532, 3250]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| >>> report.is_valid
| False
|
| Show what the issue(s) are.
|
| >>> report.invalid_fields
| ('non_convex',)
|
| Show the cell ids of the non-convex cells.
|
| >>> report.non_convex
| [1013, 1532, 3250]
|
| Access the same underlying mesh array of non-convex cell ids that was internally computed
| by :meth:`~pyvista.DataObjectFilters.cell_validator`.
|
| >>> report.mesh.field_data['non_convex']
| pyvista_ndarray([1013, 1532, 3250])
|
| Print the message generated by the report. This is the message used when the
| ``action`` keyword is set for emitting warnings or raising errors.
|
| >>> print(report.message)
| PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Show a validation report for cells with intersecting edges and unused points only.
|
| >>> report = mesh.validate_mesh(
| ... ['intersecting_edges', 'unused_points'], report_body='fields'
| ... )
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : PolyData
| N Points : 2903
| N Cells : 3263
| Cell types : {TRIANGLE, POLYGON, QUAD}
| Report summary:
| Is valid : True
| Invalid fields : ()
| Invalid point ids:
| Unused points : []
| Invalid cell ids:
| Intersecting edges : []
|
| Even though other fields are invalid (i.e. ``non_convex``), for `these` specific
| validation fields the mesh is considered valid.
|
| >>> report.is_valid
| True
|
| Do minimal validation to ensure the mesh properties are "memory_safe". This helps to avoid
| a segmentation fault which may be caused by invalid memory accesses by VTK. In this case,
| we use ``action`` to raise an error if the mesh is not valid.
|
| >>> _ = mesh.validate_mesh('memory_safe', action='error')
|
| Validate the mesh as a :class:`~pyvista.MultiBlock` instead.
|
| >>> multi = mesh.cast_to_multiblock()
| >>> report = multi.validate_mesh()
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Error message:
| MultiBlock mesh is not valid:
| * Block id 0 'Block-00' PolyData mesh is not valid:
| - Mesh has 3 non-convex QUAD cells. Invalid cell ids: [1013, 1532, 3250]
|
| Validate again but show the fields in report body.
| Instead of reporting problems with specific arrays, point ids, or cell ids, the errors
| are reported by block id. Here, block id ``0`` is reported as having non-convex cells.
|
| >>> report = multi.validate_mesh(report_body='fields')
| >>> print(report)
| Mesh Validation Report
| ----------------------
| Mesh info:
| Type : MultiBlock
| N Blocks : 1
| Report summary:
| Is valid : False
| Invalid fields (1) : ('non_convex',)
| Blocks with invalid data arrays:
| Cell data wrong length : []
| Point data wrong length : []
| Blocks with invalid points:
| Non-finite points : []
| Unused points : []
| Blocks with invalid cells:
| Coincident points : []
| Degenerate faces : []
| Intersecting edges : []
| Intersecting faces : []
| Invalid point references : []
| Inverted faces : []
| Negative size : []
| Non-contiguous edges : []
| Non-convex (1) : [0]
| Non-planar faces : []
| Wrong number of points : []
| Zero size : []
|
| Subreports for each block can be accessed with indexing.
|
| >>> len(report)
| 1
| >>> subreport = report[0]
| >>> subreport.non_convex
| [1013, 1532, 3250]
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.dataobject.DataObject:
|
| __dir__(self: 'Self') -> 'list[str]'
| Include pending accessor names so tab completion surfaces them.
|
| Plugin-contributed accessors registered via the ``pyvista.accessors``
| entry-point group are imported lazily on first attribute access.
| Listing their names alongside the normal attribute set lets IPython
| / Jupyter / REPL tab completion surface them without paying the
| plugin import cost ahead of time.
|
| __eq__(self: 'Self', other: 'object') -> 'bool'
| Test equivalency between data objects.
|
| __getstate__(self: 'Self') -> 'tuple[FunctionType, tuple[dict[str, Any]]] | dict[str, Any]'
| Support pickle.
|
| __setstate__(self: 'Self', state: 'Any') -> 'None'
| Support unpickle.
|
| add_field_data(self: 'Self', array: 'NumpyArray[float]', name: 'str', deep: 'bool' = True) -> 'None'
| Add field data.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Parameters
| ----------
| array : sequence
| Array of data to add to the dataset as a field array.
|
| name : str
| Name to assign the field array.
|
| deep : bool, default: True
| Perform a deep copy of the data when adding it to the
| dataset.
|
| Examples
| --------
| Add field data to a PolyData dataset.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.add_field_data(np.arange(10), 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| Add field data to a ImageData dataset.
|
| >>> mesh = pv.ImageData(dimensions=(2, 2, 1))
| >>> mesh.add_field_data(['I could', 'write', 'notes', 'here'], 'my-field-data')
| >>> mesh['my-field-data']
| pyvista_ndarray(['I could', 'write', 'notes', 'here'], dtype='<U7')
|
| Add field data to a MultiBlock dataset.
|
| >>> blocks = pv.MultiBlock()
| >>> blocks.append(pv.Sphere())
| >>> blocks['cube'] = pv.Cube(center=(0, 0, -1))
| >>> blocks.add_field_data([1, 2, 3], 'my-field-data')
| >>> blocks.field_data['my-field-data']
| pyvista_ndarray([1, 2, 3])
|
| cast_to_multiblock(self) -> 'MultiBlock'
| Convert this :class:`DataObject` to a :class:`~pyvista.MultiBlock`.
|
| Uses :vtk:`vtkConvertToMultiBlockDataSet` internally.
|
| .. versionadded:: 0.47
|
| Returns
| -------
| MultiBlock
| Converted dataset.
|
| clear_field_data(self: 'Self') -> 'None'
| Remove all field data.
|
| Examples
| --------
| Add field data to a PolyData dataset and then remove it.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = range(10)
| >>> len(mesh.field_data)
| 1
| >>> mesh.clear_field_data()
| >>> len(mesh.field_data)
| 0
|
| copy(self: 'Self', deep: 'bool' = True) -> 'Self'
| Return a copy of the object.
|
| Parameters
| ----------
| deep : bool, default: True
| When ``True`` makes a full copy of the object. When
| ``False``, performs a shallow copy where the points, cell,
| and data arrays are references to the original object.
|
| Returns
| -------
| pyvista.DataSet
| Deep or shallow copy of the input. Type is identical to
| the input.
|
| Examples
| --------
| Create and make a deep copy of a PolyData object.
|
| >>> import pyvista as pv
| >>> mesh_a = pv.Sphere()
| >>> mesh_b = mesh_a.copy()
| >>> mesh_a == mesh_b
| True
|
| copy_attributes(self: 'Self', dataset: 'Self') -> 'None'
| Copy the data attributes of the input dataset object.
|
| Parameters
| ----------
| dataset : pyvista.DataSet
| Dataset to copy the data attributes from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> source = source.compute_cell_sizes()
| >>> target = pv.ImageData(dimensions=(10, 10, 5))
| >>> target.copy_attributes(source)
| >>> target.plot(scalars='Volume', show_edges=True)
|
| copy_structure(self: 'Self', dataset: 'Self') -> 'None'
| Copy the structure (geometry and topology) of the input dataset object.
|
| Parameters
| ----------
| dataset : :vtk:`vtkDataSet`
| Dataset to copy the geometry and topology from.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> source = pv.ImageData(dimensions=(10, 10, 5))
| >>> target = pv.ImageData()
| >>> target.copy_structure(source)
| >>> target.plot(show_edges=True)
|
| deep_copy(self: 'Self', to_copy: 'Self | _vtk.vtkDataObject') -> 'None'
| Overwrite this data object with another data object as a deep copy.
|
| Parameters
| ----------
| to_copy : DataObject | :vtk:`vtkDataObject`
| Data object to perform a deep copy from.
|
| head(self: 'Self', display: 'bool' = True, html: 'bool | None' = None) -> 'str'
| Return the header stats of this dataset.
|
| If in IPython, this will be formatted to HTML. Otherwise
| returns a console friendly string.
|
| Parameters
| ----------
| display : bool, default: True
| Display this header in iPython.
|
| html : bool, optional
| Generate the output as HTML.
|
| Returns
| -------
| str
| Header statistics.
|
| save(self: 'Self', filename: 'Path | str', binary: 'bool' = True, texture: 'NumpyArray[np.uint8] | str | None' = None, compression: '_CompressionOptions' = 'zlib', **writer_kwargs: 'Any') -> 'None'
| Save this vtk object to file.
|
| .. include:: /api/utilities/mesh_io.rst
|
| .. versionadded:: 0.45
|
| Support saving pickled meshes
|
| See Also
| --------
| pyvista.read
|
| Parameters
| ----------
| filename : str, pathlib.Path
| Filename of output file. Writer type is inferred from
| the extension of the filename.
|
| binary : bool, default: True
| If ``True``, write as binary. Otherwise, write as ASCII.
|
| texture : str, np.ndarray, optional
| Write a single texture array to file when using a PLY
| file. Texture array must be a 3 or 4 component array with
| the datatype ``np.uint8``. Array may be a cell array or a
| point array, and may also be a string if the array already
| exists in the PolyData.
|
| If a string is provided, the texture array will be saved
| to disk as that name. If an array is provided, the
| texture array will be saved as ``'RGBA'``
|
| .. note::
| This feature is only available when saving PLY files.
|
| compression : str or None, default: 'zlib'
| The compression type to use when ``binary`` is ``True``
| and VTK writer is of type :vtk:`vtkXMLWriter`. This
| argument has no effect otherwise. Acceptable values are
| ``'zlib'``, ``'lz4'``, ``'lzma'``, and ``None``. ``None``
| indicates no compression.
|
| .. versionadded:: 0.47
|
| **writer_kwargs : dict, optional
| Additional keyword arguments forwarded verbatim to a custom
| writer registered via :func:`pyvista.register_writer`. Use
| these to expose format-specific options such as compression
| level or thread count. When the target extension dispatches
| to a built-in VTK writer or to the pickle path, passing any
| extra keyword arguments raises :class:`TypeError` — PyVista
| never silently drops writer options.
|
| .. versionadded:: 0.48
|
| Raises
| ------
| TypeError
| If ``**writer_kwargs`` are provided but the target extension
| does not dispatch to a registered custom writer.
| ValueError
| If ``file_ext`` is not a supported extension.
|
| Notes
| -----
| Binary files write much faster than ASCII and have a smaller
| file size.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pyvista.core.dataobject.DataObject:
|
| actual_memory_size
| Return the actual size of the dataset object.
|
| Returns
| -------
| int
| The actual size of the dataset object in kibibytes (1024
| bytes).
|
| Examples
| --------
| >>> from pyvista import examples
| >>> mesh = examples.load_airplane()
| >>> mesh.actual_memory_size # doctest:+SKIP
| 93
|
| field_data
| Return FieldData as DataSetAttributes.
|
| Use field data when size of the data you wish to associate
| with the dataset does not match the number of points or cells
| of the dataset.
|
| Returns
| -------
| DataSetAttributes
| FieldData as DataSetAttributes.
|
| Examples
| --------
| Add field data to a PolyData dataset and then return it.
|
| >>> import pyvista as pv
| >>> import numpy as np
| >>> mesh = pv.Sphere()
| >>> mesh.field_data['my-field-data'] = np.arange(10)
| >>> mesh.field_data['my-field-data']
| pyvista_ndarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
| memory_address
| Get address of the underlying VTK C++ object.
|
| Returns
| -------
| str
| Memory address formatted as ``'Addr=%p'``.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.memory_address
| 'Addr=...'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.dataobject.DataObject:
|
| user_dict
| Set or return a user-specified data dictionary.
|
| The dictionary is stored as a JSON-serialized string as part of the mesh's
| field data. Unlike regular field data, which requires values to be stored
| as an array, the user dict provides a mapping for scalar values.
|
| Since the user dict is stored as field data, it is automatically saved
| with the mesh when it is saved in a compatible file format (e.g. ``'.vtk'``).
| Any saved metadata is automatically de-serialized by PyVista whenever
| the user dict is accessed again. Since the data is stored as JSON, it
| may also be easily retrieved or read by other programs.
|
| Any JSON-serializable values are permitted by the user dict, i.e. values
| can have type ``dict``, ``list``, ``tuple``, ``str``, ``int``, ``float``,
| ``bool``, or ``None``. Storing NumPy arrays is not directly supported, but
| these may be cast beforehand to a supported type, e.g. by calling ``tolist()``
| on the array.
|
| To completely remove the user dict string from the dataset's field data,
| set its value to ``None``.
|
| .. note::
|
| The user dict is a convenience property intended for metadata storage.
| Values are JSON-serialized on every mutation, so it is not a substitute
| for a regular field data array when storing bulk array data with many
| entries (use a regular field data array for that instead).
|
| .. warning::
|
| Field data is typically passed-through by dataset filters, and therefore
| the user dict's items can generally be expected to persist and remain
| unchanged in the output of filtering methods. However, this behavior is
| not guaranteed, as it's possible that some filters may modify or clear
| field data. Use with caution.
|
| .. versionadded:: 0.44
|
| Returns
| -------
| UserDict
| JSON-serialized dict-like object which is subclassed from
| :py:class:`collections.UserDict`.
|
| Examples
| --------
| Load a mesh.
|
| >>> import pyvista as pv
| >>> from pyvista import examples
| >>> mesh = examples.load_ant()
|
| Add data to the user dict. The contents are serialized as JSON.
|
| >>> mesh.user_dict['name'] = 'ant'
| >>> mesh.user_dict
| {"name": "ant"}
|
| Alternatively, set the user dict from an existing dict.
|
| >>> mesh.user_dict = dict(name='ant')
|
| The user dict can be updated like a regular dict.
|
| >>> mesh.user_dict.update(
| ... {
| ... 'num_legs': 6,
| ... 'body_parts': ['head', 'thorax', 'abdomen'],
| ... }
| ... )
| >>> mesh.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| Data in the user dict is stored as field data.
|
| >>> mesh.field_data
| pyvista DataSetAttributes
| Association : NONE
| Contains arrays :
| _PYVISTA_USER_DICT str "{"name": "ant",..."
|
| Since it's field data, the user dict can be saved to file along with the
| mesh and retrieved later.
|
| >>> mesh.save('ant.vtk')
| >>> mesh_from_file = pv.read('ant.vtk')
| >>> mesh_from_file.user_dict
| {"name": "ant", "num_legs": 6, "body_parts": ["head", "thorax", "abdomen"]}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pyvista.core.dataobject.DataObject:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkUnstructuredGrid:
|
| AddReferenceToCell(...)
| AddReferenceToCell(self, ptId:int, cellId:int) -> None
| C++: void AddReferenceToCell(vtkIdType ptId, vtkIdType cellId)
|
| Allocate(...)
| Allocate(self, numCells:int=1000, extSize:int=1000) -> None
| C++: void Allocate(vtkIdType numCells=1000, int extSize=1000)
| override;
|
| Method allocates initial storage for the cell connectivity. Use
| this method before the method InsertNextCell(). The array
| capacity is doubled when the inserting a cell exceeds the current
| capacity. extSize is no longer used.
|
| ote Prefer AllocateExact or AllocateEstimate, which give more
| control over how allocations are distributed.
|
| AllocateEstimate(...)
| AllocateEstimate(self, numCells:int, maxCellSize:int) -> bool
| C++: bool AllocateEstimate(vtkIdType numCells,
| vtkIdType maxCellSize)
|
| Pre-allocate memory in internal data structures. Does not change
| the number of cells, only the array capacities. Existing data is
| NOT preserved.
| @param numCells The number of expected cells in the dataset.
| @param maxCellSize The number of points per cell to allocate
| memory for.
| @return True if allocation succeeds.
| @sa Squeeze();
|
| AllocateExact(...)
| AllocateExact(self, numCells:int, connectivitySize:int) -> bool
| C++: bool AllocateExact(vtkIdType numCells,
| vtkIdType connectivitySize)
|
| Pre-allocate memory in internal data structures. Does not change
| the number of cells, only the array capacities. Existing data is
| NOT preserved.
| @param numCells The number of expected cells in the dataset.
| @param connectivitySize The total number of pointIds stored for
| all cells.
| @return True if allocation succeeds.
| @sa Squeeze();
|
| BuildLinks(...)
| BuildLinks(self) -> None
| C++: void BuildLinks()
|
| Build topological links from points to lists of cells that use
| each point. See vtkAbstractCellLinks for more information.
|
| ConvertFaceStreamPointIds(...)
| ConvertFaceStreamPointIds(faceStream:vtkIdList, idMap:[int, ...])
| -> None
| C++: static void ConvertFaceStreamPointIds(vtkIdList *faceStream,
| vtkIdType *idMap)
| ConvertFaceStreamPointIds(nfaces:int, faceStream:[int, ...],
| idMap:[int, ...]) -> None
| C++: static void ConvertFaceStreamPointIds(vtkIdType nfaces,
| vtkIdType *faceStream, vtkIdType *idMap)
| ConvertFaceStreamPointIds(faces:vtkCellArray, idMap:[int, ...])
| -> None
| C++: static void ConvertFaceStreamPointIds(vtkCellArray *faces,
| vtkIdType *idMap)
|
| Convert pid in a face stream into idMap[pid]. The face stream is
| of format [nCellFaces, nFace0Pts, i, j, k, nFace1Pts, i, j, k,
| ...]. The user is responsible to make sure all the Ids in
| faceStream do not exceed the range of idMap.
|
| CopyStructure(...)
| CopyStructure(self, ds:vtkDataSet) -> None
| C++: void CopyStructure(vtkDataSet *ds) override;
|
| Copy the geometric structure of an input point set object.
|
| DecomposeAPolyhedronCell(...)
| DecomposeAPolyhedronCell(polyhedronCellArray:vtkCellArray,
| nCellpts:int, nCellfaces:int, cellArray:vtkCellArray,
| faces:vtkIdTypeArray) -> None
| C++: static void DecomposeAPolyhedronCell(
| vtkCellArray *polyhedronCellArray, vtkIdType &nCellpts,
| vtkIdType &nCellfaces, vtkCellArray *cellArray,
| vtkIdTypeArray *faces)
| DecomposeAPolyhedronCell(polyhedronCellStream:(int, ...),
| nCellpts:int, nCellfaces:int, cellArray:vtkCellArray,
| faces:vtkIdTypeArray) -> None
| C++: static void DecomposeAPolyhedronCell(
| const vtkIdType *polyhedronCellStream, vtkIdType &nCellpts,
| vtkIdType &nCellfaces, vtkCellArray *cellArray,
| vtkIdTypeArray *faces)
| DecomposeAPolyhedronCell(nCellFaces:int, inFaceStream:(int, ...),
| nCellpts:int, cellArray:vtkCellArray, faces:vtkIdTypeArray)
| -> None
| C++: static void DecomposeAPolyhedronCell(vtkIdType nCellFaces,
| const vtkIdType *inFaceStream, vtkIdType &nCellpts,
| vtkCellArray *cellArray, vtkIdTypeArray *faces)
|
| A static method for converting a polyhedron vtkCellArray of
| format [nCellFaces, nFace0Pts, i, j, k, nFace1Pts, i, j, k, ...]
| into three components: (1) an integer indicating the number of
| faces (2) a standard vtkCellArray storing point ids [nCell0Pts,
| i, j, k] and (3) an vtkIdTypeArray storing face connectivity in
| format [nFace0Pts, i, j, k, nFace1Pts, i, j, k, ...] Note: input
| is assumed to contain only one polyhedron cell. Outputs (2) and
| (3) will be stacked at the end of the input cellArray and faces.
| The original data in the input will not be touched.
|
| DeepCopy(...)
| DeepCopy(self, src:vtkDataObject) -> None
| C++: void DeepCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| ExtendedNew(...)
| ExtendedNew() -> vtkUnstructuredGrid
| C++: static vtkUnstructuredGrid *ExtendedNew()
|
| GetActualMemorySize(...)
| GetActualMemorySize(self) -> int
| C++: unsigned long GetActualMemorySize() override;
|
| Return the actual size of the data in kibibytes (1024 bytes).
| This number is valid only after the pipeline has updated. The
| memory size returned is guaranteed to be greater than or equal to
| the memory required to represent the data (e.g., extra space in
| arrays, etc. are not included in the return value). THIS METHOD
| IS THREAD SAFE.
|
| GetCell(...)
| GetCell(self, cellId:int) -> vtkCell
| C++: vtkCell *GetCell(vtkIdType cellId) override;
| GetCell(self, cellId:int, cell:vtkGenericCell) -> None
| C++: void GetCell(vtkIdType cellId, vtkGenericCell *cell)
| override;
| GetCell(self, i:int, j:int, k:int) -> vtkCell
| C++: virtual vtkCell *GetCell(int i, int j, int k)
|
| This method always return a `vtkEmptyCell`, as there is no cell
| in a `vtkPointSet`.
|
| GetCellBounds(...)
| GetCellBounds(self, cellId:int, bounds:[float, float, float,
| float, float, float]) -> None
| C++: void GetCellBounds(vtkIdType cellId, double bounds[6])
| override;
|
| Get the bounds of the cell with cellId such that: 0 <= cellId <
| NumberOfCells. A subclass may be able to determine the bounds of
| cell without using an expensive GetCell() method. A default
| implementation is provided that actually uses a GetCell() call.
| This is to ensure the method is available to all datasets.
| Subclasses should override this method to provide an efficient
| implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
| SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetCellLocationsArray(...)
| GetCellLocationsArray(self) -> vtkIdTypeArray
| C++: vtkIdTypeArray *GetCellLocationsArray()
|
| Get the array of all the starting indices of cell definitions in
| the cell array.
|
| @warning vtkCellArray supports random access now. This array is
| no
| longer used.
|
| GetCellNeighbors(...)
| GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
| cellIds:vtkIdList) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
| vtkIdList *cellIds) override;
| GetCellNeighbors(self, cellId:int, npts:int, ptIds:(int, ...),
| cellIds:vtkIdList) -> None
| C++: void GetCellNeighbors(vtkIdType cellId, vtkIdType npts,
| const vtkIdType *ptIds, vtkIdList *cellIds)
|
| A topological inquiry to retrieve all of the cells using list of
| points exclusive of the current cell specified (e.g., cellId).
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED.
|
| GetCellNumberOfFaces(...)
| GetCellNumberOfFaces(self, cellId:int, cellType:int,
| cell:vtkGenericCell) -> int
| C++: int GetCellNumberOfFaces(vtkIdType cellId,
| unsigned char &cellType, vtkGenericCell *cell) override;
|
| Get the number of faces of a cell.
|
| Most of the times extracting the number of faces requires only
| extracting the cell type. However, for some cell types, the
| number of faces is not constant. For example, a convex point set
| cell can have a different number of faces for each cell. That's
| why this method requires the cell id and the dataset.
|
| GetCellPoints(...)
| GetCellPoints(self, cellId:int, ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
| override;
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...)) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts)
| GetCellPoints(self, cellId:int, npts:int, pts:(int, ...),
| ptIds:vtkIdList) -> None
| C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
| vtkIdType const *&pts, vtkIdList *ptIds) override;
|
| Topological inquiry to get points defining cell. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| GetCellSize(...)
| GetCellSize(self, cellId:int) -> int
| C++: vtkIdType GetCellSize(vtkIdType cellId) override;
|
| Get the size of the cell with given cellId.
|
| GetCellType(...)
| GetCellType(self, cellId:int) -> int
| C++: int GetCellType(vtkIdType cellId) override;
|
| Get the type of the cell with the given cellId.
|
| GetCellTypes(...)
| GetCellTypes(self, types:vtkCellTypes) -> None
| C++: void GetCellTypes(vtkCellTypes *types) override;
| GetCellTypes(self) -> vtkDataArray
| C++: vtkDataArray *GetCellTypes()
|
| GetCellTypesArray(...)
| GetCellTypesArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellTypesArray()
|
| GetCells(...)
| GetCells(self) -> vtkCellArray
| C++: vtkCellArray *GetCells()
|
| Return the unstructured grid connectivity array.
|
| GetData(...)
| GetData(info:vtkInformation) -> vtkUnstructuredGrid
| C++: static vtkUnstructuredGrid *GetData(vtkInformation *info)
| GetData(v:vtkInformationVector, i:int=0) -> vtkUnstructuredGrid
| C++: static vtkUnstructuredGrid *GetData(vtkInformationVector *v,
| int i=0)
|
| Retrieve an instance of this class from an information object.
|
| GetDataObjectType(...)
| GetDataObjectType(self) -> int
| C++: int GetDataObjectType() override;
|
| Standard vtkDataSet API methods. See vtkDataSet for more
| information.
|
| GetDistinctCellTypes(...)
| GetDistinctCellTypes(self, types:vtkCellTypes) -> None
| C++: void GetDistinctCellTypes(vtkCellTypes *types) override;
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset with 5 triangles, 3 lines,
| and 100 hexahedra would result in a list of three entries,
| corresponding to the types VTK_TRIANGLE, VTK_LINE, and
| VTK_HEXAHEDRON. This override implements an optimization that
| recomputes cell types only when the types of cells may have
| changed.
|
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetDistinctCellTypesArray(...)
| GetDistinctCellTypesArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetDistinctCellTypesArray()
|
| Get a list of types of cells in a dataset. The list consists of
| an array of types (not necessarily in any order), with a single
| entry per type. For example a dataset with 5 triangles, 3 lines,
| and 100 hexahedra would result in a list of three entries,
| corresponding to the types VTK_TRIANGLE, VTK_LINE, and
| VTK_HEXAHEDRON. This override implements an optimization that
| recomputes cell types only when the types of cells may have
| changed. This method never returns `nullptr`.
|
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetFaceStream(...)
| GetFaceStream(self, cellId:int, ptIds:vtkIdList) -> None
| C++: void GetFaceStream(vtkIdType cellId, vtkIdList *ptIds)
|
| Get the face stream of a polyhedron cell in the following format:
| (numCellFaces, numFace0Pts, id1, id2, id3, numFace1Pts,id1, id2,
| id3, ...). If the requested cell is not a polyhedron, then the
| standard GetCellPoints is called to return a list of unique point
| ids (id1, id2, id3, ...). This function is threadsafe.
|
| GetGhostLevel(...)
| GetGhostLevel(self) -> int
| C++: virtual int GetGhostLevel()
|
| Get the ghost level.
|
| GetIdsOfCellsOfType(...)
| GetIdsOfCellsOfType(self, type:int, array:vtkIdTypeArray) -> None
| C++: void GetIdsOfCellsOfType(int type, vtkIdTypeArray *array)
| override;
|
| Fill vtkIdTypeArray container with list of cell Ids. This method
| traverses all cells and, for a particular cell type, inserts the
| cell Id into the container.
|
| GetLinks(...)
| GetLinks(self) -> vtkAbstractCellLinks
| C++: virtual vtkAbstractCellLinks *GetLinks()
|
| GetMaxCellSize(...)
| GetMaxCellSize(self) -> int
| C++: int GetMaxCellSize() override;
|
| Get the size, in number of points, of the largest cell.
|
| GetMaxSpatialDimension(...)
| GetMaxSpatialDimension(self) -> int
| C++: int GetMaxSpatialDimension() override;
|
| Get the maximum/minimum spatial dimensionality of the data which
| is the maximum/minimum dimension of all cells.
|
| GetMeshMTime(...)
| GetMeshMTime(self) -> int
| C++: vtkMTimeType GetMeshMTime() override;
|
| Return the mesh (geometry/topology) modification time. This time
| is different from the usual MTime which also takes into account
| the modification of data arrays. This function can be used to
| track the changes on the mesh separately from the data arrays
| (eg. static mesh over time with transient data).
|
| GetMinSpatialDimension(...)
| GetMinSpatialDimension(self) -> int
| C++: int GetMinSpatialDimension() override;
|
| GetNumberOfCells(...)
| GetNumberOfCells(self) -> int
| C++: vtkIdType GetNumberOfCells() override;
|
| This method always returns 0, as there are no cells in a
| `vtkPointSet`.
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfPieces(...)
| GetNumberOfPieces(self) -> int
| C++: virtual int GetNumberOfPieces()
|
| GetPiece(...)
| GetPiece(self) -> int
| C++: virtual int GetPiece()
|
| Set / Get the piece and the number of pieces. Similar to extent
| in 3D.
|
| GetPointCells(...)
| GetPointCells(self, ptId:int, cellIds:vtkIdList) -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
| override;
| GetPointCells(self, ptId:int, ncells:int, cells:[int, ...])
| -> None
| C++: void GetPointCells(vtkIdType ptId, vtkIdType &ncells,
| vtkIdType *&cells)
|
| Topological inquiry to get cells using point. THIS METHOD IS
| THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
| IS NOT MODIFIED
|
| GetPolyhedronFaceLocations(...)
| GetPolyhedronFaceLocations(self) -> vtkCellArray
| C++: vtkCellArray *GetPolyhedronFaceLocations()
|
| GetPolyhedronFaces(...)
| GetPolyhedronFaces(self, cellId:int, faces:vtkCellArray) -> None
| C++: void GetPolyhedronFaces(vtkIdType cellId,
| vtkCellArray *faces)
| GetPolyhedronFaces(self) -> vtkCellArray
| C++: vtkCellArray *GetPolyhedronFaces()
|
| Special support for polyhedron. Do not handle all other cell
| types.
|
| Initialize(...)
| Initialize(self) -> None
| C++: void Initialize() override;
|
| Reset the grid to an empty state and free any memory.
|
| InitializeFacesRepresentation(...)
| InitializeFacesRepresentation(self, numPrevCells:int) -> int
| C++: int InitializeFacesRepresentation(vtkIdType numPrevCells)
|
| Special function used by vtkUnstructuredGridReader. By default
| vtkUnstructuredGrid does not contain face information, which is
| only used by polyhedron cells. If so far no polyhedron cells have
| been added, Faces and FaceLocations pointers will be nullptr. In
| this case, need to initialize the arrays and assign values to the
| previous non-polyhedron cells.
|
| InsertNextLinkedCell(...)
| InsertNextLinkedCell(self, type:int, npts:int, pts:(int, ...))
| -> int
| C++: vtkIdType InsertNextLinkedCell(int type, int npts,
| const vtkIdType pts[])
|
| Use these methods only if the dataset has been specified as
| Editable. See vtkPointSet for more information.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsCellBoundary(...)
| IsCellBoundary(self, cellId:int, npts:int, ptIds:(int, ...),
| neighborCellId:int) -> bool
| C++: bool IsCellBoundary(vtkIdType cellId, vtkIdType npts,
| const vtkIdType *ptIds, vtkIdType &neighborCellId)
| IsCellBoundary(self, cellId:int, npts:int, ptIds:(int, ...))
| -> bool
| C++: bool IsCellBoundary(vtkIdType cellId, vtkIdType npts,
| const vtkIdType *ptIds)
|
| A topological inquiry to determine whether a topological entity
| (e.g., point, edge, or face) defined by the point ids (ptIds of
| length npts) is a boundary entity of a specified cell (indicated
| by cellId). A boundary entity is a topological feature used by
| exactly one cell. This method is related to GetCellNeighbors()
| except that it simply indicates whether a topological feature is
| boundary - hence the method is faster. THIS METHOD IS THREAD SAFE
| IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT
| MODIFIED.
|
| IsHomogeneous(...)
| IsHomogeneous(self) -> int
| C++: int IsHomogeneous() override;
|
| Returns whether cells are all of the same type.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| NewCellIterator(...)
| NewCellIterator(self) -> vtkCellIterator
| C++: vtkCellIterator *NewCellIterator() override;
|
| Return an iterator that traverses the cells in this data set.
|
| NewInstance(...)
| NewInstance(self) -> vtkUnstructuredGrid
| C++: vtkUnstructuredGrid *NewInstance()
|
| RemoveGhostCells(...)
| RemoveGhostCells(self) -> None
| C++: void RemoveGhostCells()
|
| This method will remove any cell that is marked as ghost (has the
| vtkDataSetAttributes::DUPLICATECELL or the
| vtkDataSetAttributes::HIDDENCELL bit set).
|
| RemoveReferenceToCell(...)
| RemoveReferenceToCell(self, ptId:int, cellId:int) -> None
| C++: void RemoveReferenceToCell(vtkIdType ptId, vtkIdType cellId)
|
| Reset(...)
| Reset(self) -> None
| C++: void Reset()
|
| Standard vtkDataSet methods; see vtkDataSet.h for documentation.
|
| ResizeCellList(...)
| ResizeCellList(self, ptId:int, size:int) -> None
| C++: void ResizeCellList(vtkIdType ptId, int size)
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkUnstructuredGrid
| C++: static vtkUnstructuredGrid *SafeDownCast(vtkObjectBase *o)
|
| SetCells(...)
| SetCells(self, type:int, cells:vtkCellArray) -> None
| C++: void SetCells(int type, vtkCellArray *cells)
| SetCells(self, types:[int, ...], cells:vtkCellArray) -> None
| C++: void SetCells(int *types, vtkCellArray *cells)
| SetCells(self, cellTypes:vtkDataArray, cells:vtkCellArray) -> None
| C++: void SetCells(vtkDataArray *cellTypes, vtkCellArray *cells)
| SetCells(self, cellTypes:vtkUnsignedCharArray, cells:vtkCellArray,
| faceLocations:vtkIdTypeArray, faces:vtkIdTypeArray) -> None
| C++: void SetCells(vtkUnsignedCharArray *cellTypes,
| vtkCellArray *cells, vtkIdTypeArray *faceLocations,
| vtkIdTypeArray *faces)
| SetCells(self, cellTypes:vtkUnsignedCharArray,
| cellLocations:vtkIdTypeArray, cells:vtkCellArray) -> None
| C++: void SetCells(vtkUnsignedCharArray *cellTypes,
| vtkIdTypeArray *cellLocations, vtkCellArray *cells)
| SetCells(self, cellTypes:vtkUnsignedCharArray,
| cellLocations:vtkIdTypeArray, cells:vtkCellArray,
| faceLocations:vtkIdTypeArray, faces:vtkIdTypeArray) -> None
| C++: void SetCells(vtkUnsignedCharArray *cellTypes,
| vtkIdTypeArray *cellLocations, vtkCellArray *cells,
| vtkIdTypeArray *faceLocations, vtkIdTypeArray *faces)
|
| Provide cell information to define the dataset with a single
| type.
|
| ote This method will create a vtkConstantArray<unsigned char> for
| the cell types internally to save memory. Therefore, if extracted
| via GetCellTypes(), it should NOT be assumed that it is a
| vtkUnsignedCharArray.
|
| SetLinks(...)
| SetLinks(self, _arg:vtkAbstractCellLinks) -> None
| C++: virtual void SetLinks(vtkAbstractCellLinks *_arg)
|
| Set/Get the links that you created possibly without using
| BuildLinks.
|
| SetPolyhedralCells(...)
| SetPolyhedralCells(self, cellTypes:vtkDataArray,
| cells:vtkCellArray, faceLocations:vtkCellArray,
| faces:vtkCellArray) -> None
| C++: void SetPolyhedralCells(vtkDataArray *cellTypes,
| vtkCellArray *cells, vtkCellArray *faceLocations,
| vtkCellArray *faces)
|
| ShallowCopy(...)
| ShallowCopy(self, src:vtkDataObject) -> None
| C++: void ShallowCopy(vtkDataObject *src) override;
|
| Shallow and Deep copy.
|
| Squeeze(...)
| Squeeze(self) -> None
| C++: void Squeeze() override;
|
| Squeeze all arrays in the grid to conserve memory.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkUnstructuredGrid:
|
| __this__
| Pointer to the C++ object.
|
| cell_locations_array
| read-only, calls GetCellLocationsArray
|
| cell_types
| read-only, calls GetCellTypes
|
| cell_types_array
| read-only, calls GetCellTypesArray
|
| data_object_type
| read-only, calls GetDataObjectType
|
| distinct_cell_types_array
| read-only, calls GetDistinctCellTypesArray
|
| ghost_level
| read-only, calls GetGhostLevel
|
| links
| read-write, calls GetLinks/SetLinks
|
| max_cell_size
| read-only, calls GetMaxCellSize
|
| max_spatial_dimension
| read-only, calls GetMaxSpatialDimension
|
| mesh_m_time
| read-only, calls GetMeshMTime
|
| min_spatial_dimension
| read-only, calls GetMinSpatialDimension
|
| number_of_pieces
| read-only, calls GetNumberOfPieces
|
| piece
| read-only, calls GetPiece
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkUnstructuredGrid:
|
| __vtkname__ = 'vtkUnstructuredGrid'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkUnstructuredGridBase:
|
| InsertNextCell(...)
| InsertNextCell(self, type:int, npts:int, ptIds:(int, ...)) -> int
| C++: vtkIdType InsertNextCell(int type, vtkIdType npts,
| const vtkIdType ptIds[])
| InsertNextCell(self, type:int, ptIds:vtkIdList) -> int
| C++: vtkIdType InsertNextCell(int type, vtkIdList *ptIds)
| InsertNextCell(self, type:int, npts:int, ptIds:(int, ...),
| nfaces:int, faces:(int, ...)) -> int
| C++: vtkIdType InsertNextCell(int type, vtkIdType npts,
| const vtkIdType ptIds[], vtkIdType nfaces,
| const vtkIdType faces[])
| InsertNextCell(self, type:int, npts:int, ptIds:(int, ...),
| faces:vtkCellArray) -> int
| C++: vtkIdType InsertNextCell(int type, vtkIdType npts,
| const vtkIdType ptIds[], vtkCellArray *faces)
|
| Insert/create cell in object by type and list of point ids
| defining cell topology. Most cells require just a type which
| implicitly defines a set of points and their ordering. For
| non-polyhedron cell type, npts is the number of unique points in
| the cell. pts are the list of global point Ids. For polyhedron
| cell, a special input format is required. npts is the number of
| faces in the cell. ptIds is the list of face stream:
| (numFace0Pts, id1, id2, id3, numFace1Pts,id1, id2, id3, ...) Make
| sure you have called Allocate() before calling this method
|
| ReplaceCell(...)
| ReplaceCell(self, cellId:int, npts:int, pts:(int, ...)) -> None
| C++: void ReplaceCell(vtkIdType cellId, int npts,
| const vtkIdType pts[])
|
| Replace the points defining cell "cellId" with a new set of
| points. This operator is (typically) used when links from points
| to cells have not been built (i.e., BuildLinks() has not been
| executed). Use the operator ReplaceLinkedCell() to replace a cell
| when cell structure has been built.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| BuildCellLocator(...)
| BuildCellLocator(self) -> None
| C++: void BuildCellLocator()
|
| Build the cell locator. In a multi-threaded environment, call
| this method in a single thread before using FindCell().
|
| BuildLocator(...)
| BuildLocator(self) -> None
| C++: void BuildLocator()
|
| BuildPointLocator(...)
| BuildPointLocator(self) -> None
| C++: void BuildPointLocator()
|
| Build the internal point locator . In a multi-threaded
| environment, call this method in a single thread before using
| FindCell() or FindPoint().
|
| ComputeBounds(...)
| ComputeBounds(self) -> None
| C++: void ComputeBounds() override;
|
| Compute the (X, Y, Z) bounds of the data.
|
| EditableOff(...)
| EditableOff(self) -> None
| C++: virtual void EditableOff()
|
| EditableOn(...)
| EditableOn(self) -> None
| C++: virtual void EditableOn()
|
| FindCell(...)
| FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int,
| tol2:float, subId:int, pcoords:[float, float, float],
| weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights) override;
| FindCell(self, x:[float, float, float], cell:vtkCell,
| gencell:vtkGenericCell, cellId:int, tol2:float, subId:int,
| pcoords:[float, float, float], weights:[float, ...]) -> int
| C++: vtkIdType FindCell(double x[3], vtkCell *cell,
| vtkGenericCell *gencell, vtkIdType cellId, double tol2,
| int &subId, double pcoords[3], double *weights) override;
|
| Locate cell based on global coordinate x and tolerance squared.
| If cell and cellId is non-nullptr, then search starts from this
| cell and looks at immediate neighbors. Returns cellId >= 0 if
| inside, < 0 otherwise. The parametric coordinates are provided
| in pcoords[3]. The interpolation weights are returned in
| weights[]. (The number of weights is equal to the number of
| points in the found cell). Tolerance is used to control how close
| the point is to be considered "in" the cell. THIS METHOD IS NOT
| THREAD SAFE.
|
| FindPoint(...)
| FindPoint(self, x:[float, float, float]) -> int
| C++: vtkIdType FindPoint(double x[3]) override;
|
| GetCellLocator(...)
| GetCellLocator(self) -> vtkAbstractCellLocator
| C++: virtual vtkAbstractCellLocator *GetCellLocator()
|
| GetEditable(...)
| GetEditable(self) -> bool
| C++: virtual bool GetEditable()
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Get MTime which also considers its vtkPoints MTime.
|
| GetNumberOfPoints(...)
| GetNumberOfPoints(self) -> int
| C++: vtkIdType GetNumberOfPoints() override;
|
| See vtkDataSet for additional information.
|
| GetPoint(...)
| GetPoint(self, ptId:int, x:[float, float, float]) -> None
| C++: void GetPoint(vtkIdType ptId, double x[3]) override;
| GetPoint(self, ptId:int) -> (float, float, float)
| C++: double *GetPoint(vtkIdType ptId) override;
|
| Copy point coordinates into user provided array x[3] for
| specified point id. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| GetPointLocator(...)
| GetPointLocator(self) -> vtkAbstractPointLocator
| C++: virtual vtkAbstractPointLocator *GetPointLocator()
|
| GetPoints(...)
| GetPoints(self) -> vtkPoints
| C++: vtkPoints *GetPoints() override;
|
| If the subclass has (implicit/explicit) points, then return them.
| Otherwise, create a vtkPoints object and return that.
|
| DO NOT MODIFY THE RETURNED POINTS OBJECT.
|
| SetCellLocator(...)
| SetCellLocator(self, __a:vtkAbstractCellLocator) -> None
| C++: virtual void SetCellLocator(vtkAbstractCellLocator *)
|
| Set / get an instance of vtkAbstractCellLocator which may be used
| when a vtkCellLocatorStrategy is used during a FindCell()
| operation.
|
| SetEditable(...)
| SetEditable(self, _arg:bool) -> None
| C++: virtual void SetEditable(bool _arg)
|
| Specify whether this dataset is editable after creation. Meaning,
| once the points and cells are defined, can the dataset be
| incrementally modified. By default, this dataset is non-editable
| (i.e., "static") after construction. The reason for this is
| performance: cell links and locators can be built (and destroyed)
| much faster is it is known that the data is static (see
| vtkStaticCellLinks, vtkStaticPointLocator, vtkStaticCellLocator).
|
| SetPointLocator(...)
| SetPointLocator(self, __a:vtkAbstractPointLocator) -> None
| C++: virtual void SetPointLocator(vtkAbstractPointLocator *)
|
| Set / get an instance of vtkAbstractPointLocator which is used to
| support the FindPoint() and FindCell() methods. By default a
| vtkStaticPointLocator is used, unless the class is set as
| Editable, in which case a vtkPointLocator is used.
|
| SetPoints(...)
| SetPoints(self, __a:vtkPoints) -> None
| C++: virtual void SetPoints(vtkPoints *)
|
| Specify point array to define point coordinates.
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: bool UsesGarbageCollector() override;
|
| Overwritten to handle the data/locator loop
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkPointSet:
|
| cell_locator
| read-write, calls GetCellLocator/SetCellLocator
|
| editable
| read-write, calls GetEditable/SetEditable
|
| m_time
| read-only, calls GetMTime
|
| point_locator
| read-write, calls GetPointLocator/SetPointLocator
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| AllocateCellGhostArray(...)
| AllocateCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocateCellGhostArray()
|
| Allocate ghost array for cells.
|
| AllocatePointGhostArray(...)
| AllocatePointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *AllocatePointGhostArray()
|
| Allocate ghost array for points.
|
| CheckAttributes(...)
| CheckAttributes(self) -> int
| C++: int CheckAttributes()
|
| This method checks to see if the cell and point attributes match
| the geometry. Many filters will crash if the number of tuples in
| an array is less than the number of points/cells. This method
| returns 1 if there is a mismatch, and 0 if everything is ok. It
| prints an error if an array is too short, and a warning if an
| array is too long.
|
| CopyAttributes(...)
| CopyAttributes(self, ds:vtkDataSet) -> None
| C++: virtual void CopyAttributes(vtkDataSet *ds)
|
| Copy the attributes associated with the specified dataset to this
| instance of vtkDataSet. THIS METHOD IS NOT THREAD SAFE.
|
| FindAndGetCell(...)
| FindAndGetCell(self, x:[float, float, float], cell:vtkCell,
| cellId:int, tol2:float, subId:int, pcoords:[float, float,
| float], weights:[float, ...]) -> vtkCell
| C++: virtual vtkCell *FindAndGetCell(double x[3], vtkCell *cell,
| vtkIdType cellId, double tol2, int &subId, double pcoords[3],
| double *weights)
|
| Locate the cell that contains a point and return the cell. Also
| returns the subcell id, parametric coordinates and weights for
| subsequent interpolation. This method combines the derived class
| methods int FindCell and vtkCell *GetCell. Derived classes may
| provide a more efficient implementation. See for example
| vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE.
|
| GenerateGhostArray(...)
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int])
| -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6])
| GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int],
| cellOnly:bool) -> None
| C++: virtual void GenerateGhostArray(int zeroExt[6],
| bool cellOnly)
|
| Normally called by pipeline executives or algorithms only. This
| method computes the ghost arrays for a given dataset. The zeroExt
| argument specifies the extent of the region which ghost type = 0.
|
| GetAttributesAsFieldData(...)
| GetAttributesAsFieldData(self, type:int) -> vtkFieldData
| C++: vtkFieldData *GetAttributesAsFieldData(int type) override;
|
| Returns the attributes of the data object as a vtkFieldData. This
| returns non-null values in all the same cases as GetAttributes,
| in addition to the case of FIELD, which will return the field
| data for any vtkDataObject subclass.
|
| GetBounds(...)
| GetBounds(self) -> (float, float, float, float, float, float)
| C++: double *GetBounds()
| GetBounds(self, bounds:[float, float, float, float, float, float])
| -> None
| C++: void GetBounds(double bounds[6])
|
| Return a pointer to the geometry bounding box in the form
| (xmin,xmax, ymin,ymax, zmin,zmax). THIS METHOD IS NOT THREAD
| SAFE.
|
| GetCellData(...)
| GetCellData(self) -> vtkCellData
| C++: vtkCellData *GetCellData()
|
| Return a pointer to this dataset's cell data. THIS METHOD IS
| THREAD SAFE
|
| GetCellGhostArray(...)
| GetCellGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetCellGhostArray()
|
| Get the array that defines the ghost type of each cell. We cache
| the pointer to the array to save a lookup involving string
| comparisons
|
| GetCenter(...)
| GetCenter(self) -> (float, float, float)
| C++: double *GetCenter()
| GetCenter(self, center:[float, float, float]) -> None
| C++: void GetCenter(double center[3])
|
| Get the center of the bounding box. THIS METHOD IS NOT THREAD
| SAFE.
|
| GetGhostArray(...)
| GetGhostArray(self, type:int) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetGhostArray(int type) override;
|
| Returns the ghost array for the given type (point or cell). Takes
| advantage of the cache with the pointer to the array to save a
| string comparison.
|
| GetLength(...)
| GetLength(self) -> float
| C++: double GetLength()
|
| Return the length of the diagonal of the bounding box. THIS
| METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
| THE DATASET IS NOT MODIFIED
|
| GetLength2(...)
| GetLength2(self) -> float
| C++: double GetLength2()
|
| Return the squared length of the diagonal of the bounding box.
| THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD
| AND THE DATASET IS NOT MODIFIED
|
| GetNumberOfElements(...)
| GetNumberOfElements(self, type:int) -> int
| C++: vtkIdType GetNumberOfElements(int type) override;
|
| Get the number of elements for a specific attribute type (POINT,
| CELL, etc.).
|
| GetPointData(...)
| GetPointData(self) -> vtkPointData
| C++: vtkPointData *GetPointData()
|
| Return a pointer to this dataset's point data. THIS METHOD IS
| THREAD SAFE
|
| GetPointGhostArray(...)
| GetPointGhostArray(self) -> vtkUnsignedCharArray
| C++: vtkUnsignedCharArray *GetPointGhostArray()
|
| Gets the array that defines the ghost type of each point. We
| cache the pointer to the array to save a lookup involving string
| comparisons
|
| GetScalarRange(...)
| GetScalarRange(self, range:[float, float]) -> None
| C++: virtual void GetScalarRange(double range[2])
| GetScalarRange(self) -> (float, float)
| C++: double *GetScalarRange()
|
| Convenience method to get the range of the first component (and
| only the first component) of any scalars in the data set. If the
| data has both point data and cell data, it returns the (min/max)
| range of combined point and cell data. If there are no point or
| cell scalars the method will return (0,1). Note: It might be
| necessary to call Update to create or refresh the scalars before
| calling this method. THIS METHOD IS THREAD SAFE IF FIRST CALLED
| FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
|
| HasAnyBlankCells(...)
| HasAnyBlankCells(self) -> bool
| C++: virtual bool HasAnyBlankCells()
|
| Returns 1 if there are any blanking cells 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyBlankPoints(...)
| HasAnyBlankPoints(self) -> bool
| C++: virtual bool HasAnyBlankPoints()
|
| Returns 1 if there are any blanking points 0 otherwise. Blanking
| is supported only for vtkStructuredGrid and vtkUniformGrid
|
| HasAnyGhostCells(...)
| HasAnyGhostCells(self) -> bool
| C++: bool HasAnyGhostCells()
|
| Returns 1 if there are any ghost cells 0 otherwise.
|
| HasAnyGhostPoints(...)
| HasAnyGhostPoints(self) -> bool
| C++: bool HasAnyGhostPoints()
|
| Returns 1 if there are any ghost points 0 otherwise.
|
| SetCellOrderAndRationalWeights(...)
| SetCellOrderAndRationalWeights(self, cellId:int,
| cell:vtkGenericCell) -> None
| C++: void SetCellOrderAndRationalWeights(vtkIdType cellId,
| vtkGenericCell *cell)
|
| SupportsGhostArray(...)
| SupportsGhostArray(self, type:int) -> bool
| C++: bool SupportsGhostArray(int type) override;
|
| Returns true for POINT or CELL, false otherwise
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| cell_ghost_array
| read-only, calls GetCellGhostArray
|
| length2
| read-only, calls GetLength2
|
| point_ghost_array
| read-only, calls GetPointGhostArray
|
| scalar_range
| read-only, calls GetScalarRange
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataSet:
|
| CELL_DATA_FIELD = 2
|
| DATA_OBJECT_FIELD = 0
|
| FieldDataType = <class 'vtkmodules.vtkCommonDataModel.vtkDataSet.Field...
|
| POINT_DATA_FIELD = 1
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| ALL_PIECES_EXTENT(...)
| ALL_PIECES_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *ALL_PIECES_EXTENT()
|
| \ingroup InformationKeys
|
| BOUNDING_BOX(...)
| BOUNDING_BOX() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *BOUNDING_BOX()
|
| \ingroup InformationKeys
|
| CELL_DATA_VECTOR(...)
| CELL_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *CELL_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| CopyInformationFromPipeline(...)
| CopyInformationFromPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationFromPipeline(
| vtkInformation *info)
|
| Copy from the pipeline information to the data object's own
| information. Called right before the main execution pass.
|
| CopyInformationToPipeline(...)
| CopyInformationToPipeline(self, info:vtkInformation) -> None
| C++: virtual void CopyInformationToPipeline(vtkInformation *info)
|
| Copy information from this data object to the pipeline
| information. This is used by the vtkTrivialProducer that is
| created when someone calls SetInputData() to connect a data
| object to a pipeline.
|
| Crop(...)
| Crop(self, updateExtent:(int, ...)) -> None
| C++: virtual void Crop(const int *updateExtent)
|
| This method crops the data object (if necessary) so that the
| extent matches the update extent.
|
| DATA_EXTENT(...)
| DATA_EXTENT() -> vtkInformationIntegerPointerKey
| C++: static vtkInformationIntegerPointerKey *DATA_EXTENT()
|
| \ingroup InformationKeys
|
| DATA_EXTENT_TYPE(...)
| DATA_EXTENT_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_EXTENT_TYPE()
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_GHOST_LEVELS(...)
| DATA_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_GHOST_LEVELS(
| )
|
| \ingroup InformationKeys
|
| DATA_NUMBER_OF_PIECES(...)
| DATA_NUMBER_OF_PIECES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_NUMBER_OF_PIECES()
|
| \ingroup InformationKeys
|
| DATA_OBJECT(...)
| DATA_OBJECT() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *DATA_OBJECT()
|
| \ingroup InformationKeys
|
| DATA_PIECE_NUMBER(...)
| DATA_PIECE_NUMBER() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *DATA_PIECE_NUMBER()
|
| \ingroup InformationKeys
|
| DATA_TIME_STEP(...)
| DATA_TIME_STEP() -> vtkInformationDoubleKey
| C++: static vtkInformationDoubleKey *DATA_TIME_STEP()
|
| \ingroup InformationKeys
|
| DATA_TYPE_NAME(...)
| DATA_TYPE_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *DATA_TYPE_NAME()
|
| \ingroup InformationKeys
|
| DIRECTION(...)
| DIRECTION() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *DIRECTION()
|
| \ingroup InformationKeys
|
| DataHasBeenGenerated(...)
| DataHasBeenGenerated(self) -> None
| C++: void DataHasBeenGenerated()
|
| This method is called by the source when it executes to generate
| data. It is sort of the opposite of ReleaseData. It sets the
| DataReleased flag to 0, and sets a new UpdateTime.
|
| EDGE_DATA_VECTOR(...)
| EDGE_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *EDGE_DATA_VECTOR()
|
| \ingroup InformationKeys
|
| FIELD_ACTIVE_ATTRIBUTE(...)
| FIELD_ACTIVE_ATTRIBUTE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ACTIVE_ATTRIBUTE()
|
| \ingroup InformationKeys
|
| FIELD_ARRAY_TYPE(...)
| FIELD_ARRAY_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ARRAY_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_ASSOCIATION(...)
| FIELD_ASSOCIATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ASSOCIATION()
|
| \ingroup InformationKeys
|
| FIELD_ATTRIBUTE_COMPONENT(...)
| FIELD_ATTRIBUTE_COMPONENT() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_COMPONENT()
|
| \ingroup InformationKeys
|
| If present, this key specifies an actual or virtual component of
| the array. Virtual components are functions of tuples that
| evaluate to a single number – such as L₁ or L₂ norms.
|
| This takes on values from the vtkArrayComponents enumeration as
| well as non-negative integers.
|
| FIELD_ATTRIBUTE_TYPE(...)
| FIELD_ATTRIBUTE_TYPE() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_ATTRIBUTE_TYPE()
|
| \ingroup InformationKeys
|
| FIELD_NAME(...)
| FIELD_NAME() -> vtkInformationStringKey
| C++: static vtkInformationStringKey *FIELD_NAME()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_COMPONENTS(...)
| FIELD_NUMBER_OF_COMPONENTS() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_COMPONENTS()
|
| \ingroup InformationKeys
|
| FIELD_NUMBER_OF_TUPLES(...)
| FIELD_NUMBER_OF_TUPLES() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_NUMBER_OF_TUPLES()
|
| \ingroup InformationKeys
|
| FIELD_OPERATION(...)
| FIELD_OPERATION() -> vtkInformationIntegerKey
| C++: static vtkInformationIntegerKey *FIELD_OPERATION()
|
| \ingroup InformationKeys
|
| FIELD_RANGE(...)
| FIELD_RANGE() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *FIELD_RANGE()
|
| \ingroup InformationKeys
|
| GetActiveFieldInformation(...)
| GetActiveFieldInformation(info:vtkInformation,
| fieldAssociation:int, attributeType:int) -> vtkInformation
| C++: static vtkInformation *GetActiveFieldInformation(
| vtkInformation *info, int fieldAssociation, int attributeType)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and
| attribute (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS)
|
| GetAssociationTypeAsString(...)
| GetAssociationTypeAsString(associationType:int) -> str
| C++: static const char *GetAssociationTypeAsString(
| int associationType)
|
| Given an integer association type, this static method returns a
| string type for the attribute (i.e. associationType = 0: returns
| "Points").
|
| GetAssociationTypeFromString(...)
| GetAssociationTypeFromString(associationName:str) -> int
| C++: static int GetAssociationTypeFromString(
| const char *associationName)
|
| Given a string association name, this static method returns an
| integer association type for the attribute (i.e. associationName
| = "Points": returns 0).
|
| GetAttributeTypeForArray(...)
| GetAttributeTypeForArray(self, arr:vtkAbstractArray) -> int
| C++: virtual int GetAttributeTypeForArray(vtkAbstractArray *arr)
|
| Retrieves the attribute type that an array came from. This is
| useful for obtaining which attribute type a input array to an
| algorithm came from (retrieved from
| GetInputAbstractArrayToProcesss).
|
| GetAttributes(...)
| GetAttributes(self, type:int) -> vtkDataSetAttributes
| C++: virtual vtkDataSetAttributes *GetAttributes(int type)
|
| Returns the attributes of the data object of the specified
| attribute type. The type may be: POINT - Defined in vtkDataSet
| subclasses. CELL - Defined in vtkDataSet subclasses. VERTEX -
| Defined in vtkGraph subclasses. EDGE - Defined in vtkGraph
| subclasses. ROW - Defined in vtkTable. The other attribute
| type, FIELD, will return nullptr since field data is stored as a
| vtkFieldData instance, not a vtkDataSetAttributes instance. To
| retrieve field data, use GetAttributesAsFieldData.
|
| @warning This method NEEDS to be
| overridden in subclasses to work as documented. If not, it
| returns nullptr for any type but FIELD.
|
| GetDataReleased(...)
| GetDataReleased(self) -> int
| C++: virtual vtkTypeBool GetDataReleased()
|
| Get the flag indicating the data has been released.
|
| GetExtentType(...)
| GetExtentType(self) -> int
| C++: virtual int GetExtentType()
|
| The ExtentType will be left as VTK_PIECES_EXTENT for data objects
| such as vtkPolyData and vtkUnstructuredGrid. The ExtentType will
| be changed to VTK_3D_EXTENT for data objects with 3D structure
| such as vtkImageData (and its subclass vtkStructuredPoints),
| vtkRectilinearGrid, and vtkStructuredGrid. The default is the
| have an extent in pieces, with only one piece (no streaming
| possible).
|
| GetFieldData(...)
| GetFieldData(self) -> vtkFieldData
| C++: virtual vtkFieldData *GetFieldData()
|
| GetGlobalReleaseDataFlag(...)
| GetGlobalReleaseDataFlag() -> int
| C++: static vtkTypeBool GetGlobalReleaseDataFlag()
|
| GetInformation(...)
| GetInformation(self) -> vtkInformation
| C++: virtual vtkInformation *GetInformation()
|
| Set/Get the information object associated with this data object.
|
| GetNamedFieldInformation(...)
| GetNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> vtkInformation
| C++: static vtkInformation *GetNamedFieldInformation(
| vtkInformation *info, int fieldAssociation, const char *name)
|
| Return the information object within the input information
| object's field data corresponding to the specified association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS) and name.
|
| GetUpdateTime(...)
| GetUpdateTime(self) -> int
| C++: vtkMTimeType GetUpdateTime()
|
| Used by Threaded ports to determine if they should initiate an
| asynchronous update (still in development).
|
| GlobalReleaseDataFlagOff(...)
| GlobalReleaseDataFlagOff(self) -> None
| C++: void GlobalReleaseDataFlagOff()
|
| GlobalReleaseDataFlagOn(...)
| GlobalReleaseDataFlagOn(self) -> None
| C++: void GlobalReleaseDataFlagOn()
|
| ORIGIN(...)
| ORIGIN() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *ORIGIN()
|
| \ingroup InformationKeys
|
| PIECE_EXTENT(...)
| PIECE_EXTENT() -> vtkInformationIntegerVectorKey
| C++: static vtkInformationIntegerVectorKey *PIECE_EXTENT()
|
| \ingroup InformationKeys
|
| POINT_DATA_VECTOR(...)
| POINT_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *POINT_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| PrepareForNewData(...)
| PrepareForNewData(self) -> None
| C++: virtual void PrepareForNewData()
|
| make the output data ready for new data to be inserted. For most
| objects we just call Initialize. But for vtkImageData we leave
| the old data in case the memory can be reused.
|
| ReleaseData(...)
| ReleaseData(self) -> None
| C++: void ReleaseData()
|
| Release data back to system to conserve memory resource. Used
| during visualization network execution. Releasing this data does
| not make down-stream data invalid.
|
| RemoveNamedFieldInformation(...)
| RemoveNamedFieldInformation(info:vtkInformation,
| fieldAssociation:int, name:str) -> None
| C++: static void RemoveNamedFieldInformation(vtkInformation *info,
| int fieldAssociation, const char *name)
|
| Remove the info associated with an array
|
| SIL(...)
| SIL() -> vtkInformationDataObjectKey
| C++: static vtkInformationDataObjectKey *SIL()
|
| \ingroup InformationKeys
|
| SPACING(...)
| SPACING() -> vtkInformationDoubleVectorKey
| C++: static vtkInformationDoubleVectorKey *SPACING()
|
| \ingroup InformationKeys
|
| SetActiveAttribute(...)
| SetActiveAttribute(info:vtkInformation, fieldAssociation:int,
| attributeName:str, attributeType:int) -> vtkInformation
| C++: static vtkInformation *SetActiveAttribute(
| vtkInformation *info, int fieldAssociation,
| const char *attributeName, int attributeType)
|
| Set the named array to be the active field for the specified type
| (SCALARS, VECTORS, NORMALS, TCOORDS, or TENSORS) and association
| (FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). Returns
| the active field information object and creates on entry if one
| not found.
|
| SetActiveAttributeInfo(...)
| SetActiveAttributeInfo(info:vtkInformation, fieldAssociation:int,
| attributeType:int, name:str, arrayType:int, numComponents:int,
| numTuples:int) -> None
| C++: static void SetActiveAttributeInfo(vtkInformation *info,
| int fieldAssociation, int attributeType, const char *name,
| int arrayType, int numComponents, int numTuples)
|
| Set the name, array type, number of components, and number of
| tuples within the passed information object for the active
| attribute of type attributeType (in specified association,
| FIELD_ASSOCIATION_POINTS or FIELD_ASSOCIATION_CELLS). If there
| is not an active attribute of the specified type, an entry in the
| information object is created. If arrayType, numComponents, or
| numTuples equal to -1, or name=nullptr the value is not changed.
|
| SetFieldData(...)
| SetFieldData(self, __a:vtkFieldData) -> None
| C++: virtual void SetFieldData(vtkFieldData *)
|
| Assign or retrieve a general field data to this data object.
|
| SetGlobalReleaseDataFlag(...)
| SetGlobalReleaseDataFlag(val:int) -> None
| C++: static void SetGlobalReleaseDataFlag(vtkTypeBool val)
|
| Turn on/off flag to control whether every object releases its
| data after being used by a filter.
|
| SetInformation(...)
| SetInformation(self, __a:vtkInformation) -> None
| C++: virtual void SetInformation(vtkInformation *)
|
| SetPointDataActiveScalarInfo(...)
| SetPointDataActiveScalarInfo(info:vtkInformation, arrayType:int,
| numComponents:int) -> None
| C++: static void SetPointDataActiveScalarInfo(
| vtkInformation *info, int arrayType, int numComponents)
|
| Convenience version of previous method for use (primarily) by the
| Imaging filters. If arrayType or numComponents == -1, the value
| is not changed.
|
| VERTEX_DATA_VECTOR(...)
| VERTEX_DATA_VECTOR() -> vtkInformationInformationVectorKey
| C++: static vtkInformationInformationVectorKey *VERTEX_DATA_VECTOR(
| )
|
| \ingroup InformationKeys
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| data_released
| read-only, calls GetDataReleased
|
| extent_type
| read-only, calls GetExtentType
|
| global_release_data_flag
| read-write, calls GetGlobalReleaseDataFlag/SetGlobalReleaseDataFlag
|
| information
| read-write, calls GetInformation/SetInformation
|
| update_time
| read-only, calls GetUpdateTime
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonDataModel.vtkDataObject:
|
| AttributeTypes = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject.A...
|
| CELL = 1
|
| EDGE = 5
|
| FIELD = 2
|
| FIELD_ASSOCIATION_CELLS = 1
|
| FIELD_ASSOCIATION_EDGES = 5
|
| FIELD_ASSOCIATION_NONE = 2
|
| FIELD_ASSOCIATION_POINTS = 0
|
| FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3
|
| FIELD_ASSOCIATION_ROWS = 6
|
| FIELD_ASSOCIATION_VERTICES = 4
|
| FIELD_OPERATION_MODIFIED = 2
|
| FIELD_OPERATION_PRESERVED = 0
|
| FIELD_OPERATION_REINTERPOLATED = 1
|
| FIELD_OPERATION_REMOVED = 3
|
| FieldAssociations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObjec...
|
| FieldOperations = <class 'vtkmodules.vtkCommonDataModel.vtkDataObject....
|
| NUMBER_OF_ASSOCIATIONS = 7
|
| NUMBER_OF_ATTRIBUTE_TYPES = 7
|
| POINT = 0
|
| POINT_THEN_CELL = 3
|
| ROW = 6
|
| VERTEX = 4
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| Modified(...)
| Modified(self) -> None
| C++: virtual void Modified()
|
| Update the modification time for this object. Many filters rely
| on the modification time to determine if they need to recompute
| their data. The modification time is a unique monotonically
| increasing unsigned long integer.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
DATA
ClassVar = typing.ClassVar
Special type construct to mark class variables.
An annotation wrapped in ClassVar indicates that a given
attribute is intended to be used as a class variable and
should not be set on instances of that class.
Usage::
class Starship:
stats: ClassVar[dict[str, int]] = {} # class variable
damage: int = 10 # instance variable
ClassVar accepts only types and cannot be further subscribed.
Note that ClassVar is not a class itself, and should not
be used with isinstance() or issubclass().
DEFAULT_INPLACE_WARNING = 'You did not specify a value for `inplace` a...
TYPE_CHECKING = False
vtk_version_info = VTKVersionInfo(major=9, minor=6, micro=2)
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\pointset.py
pyvista.principal_axes
Python Library Documentation: function principal_axes in module pyvista.core.utilities.points
principal_axes(points: 'MatrixLike[float]', *, return_std: 'bool' = False) -> 'NumpyArray[float] | tuple[NumpyArray[float], NumpyArray[float]]'
Compute the principal axes of a set of points.
Principal axes are orthonormal vectors that best fit a set of points. The axes
are also known as the principal components in Principal Component Analysis (PCA),
or the right singular vectors from the Singular Value Decomposition (SVD).
The axes are computed as the eigenvectors of the covariance matrix from the
mean-centered points, and are processed to ensure that they form a right-handed
coordinate frame.
The axes explain the total variance of the points. The first axis explains the
largest percentage of variance, followed by the second axis, followed again by
the third axis which explains the smallest percentage of variance.
The axes may be used to build an oriented bounding box or to align the points to
another set of axes (e.g. the world XYZ axes).
.. note::
The computed axes are not unique, and the sign of each axis direction can be
arbitrarily changed.
.. note::
This implementation creates a temporary array of the same size as the input
array, and is therefore not optimal in terms of its memory requirements.
A more memory-efficient computation may be supported in a future release.
.. versionadded:: 0.45.0
See Also
--------
fit_plane_to_points
Fit a plane to points using the first two principal axes.
pyvista.DataSetFilters.align_xyz
Filter which aligns principal axes to the x-y-z axes.
:ref:`point_cloud_orientation_example`
Example using this function with point clouds.
Parameters
----------
points : MatrixLike[float]
Nx3 array of points.
return_std : bool, default: False
If ``True``, also returns the standard deviation of the points along each axis.
Standard deviation is computed as the square root of the eigenvalues of the
mean-centered covariance matrix.
Returns
-------
numpy.ndarray
3x3 orthonormal array with the principal axes as row vectors.
numpy.ndarray
Three-item array of the standard deviations along each axis.
Examples
--------
>>> import pyvista as pv
>>> import numpy as np
>>> rng = np.random.default_rng(seed=0) # only seeding for the example
Create a mesh with points that have the largest variation in ``X``,
followed by ``Y``, then ``Z``.
>>> radii = np.array((6, 3, 1)) # x-y-z radii
>>> mesh = pv.ParametricEllipsoid(
... xradius=radii[0], yradius=radii[1], zradius=radii[2]
... )
Plot the mesh and highlight its points in black.
>>> pl = pv.Plotter()
>>> _ = pl.add_mesh(mesh)
>>> _ = pl.add_points(mesh, color='black')
>>> _ = pl.show_grid()
>>> pl.show()
Compute its principal axes and return the standard deviations.
>>> axes, std = pv.principal_axes(mesh.points, return_std=True)
>>> axes # doctest:+SKIP
pyvista_ndarray([[-1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., -1.]], dtype=float32)
Note that the principal axes have ones along the diagonal and zeros
in the off-diagonal. This indicates that the first principal axis is
aligned with the x-axis, the second with the y-axis, and third with
the z-axis. This is expected, since the mesh is already axis-aligned.
However, since the signs of the principal axes are arbitrary, the
first and third axes in this case have a negative direction.
Show the standard deviation along each axis.
>>> std # doctest:+SKIP
array([3.0149 , 1.5074 , 0.7035], dtype=float32)
Compare this to using :meth:`numpy.std` for the computation.
>>> np.std(mesh.points, axis=0)
pyvista_ndarray([3.0149572, 1.5074761, 0.7035699], dtype=float32)
Since the points are axis-aligned, the two results agree in this case. In general,
however, these two methods differ in that :meth:`numpy.std` with `axis=0` computes
the standard deviation along the `x-y-z` axes, whereas the standard deviation
returned by :meth:`principal_axes` is computed along the principal axes.
Convert the values to proportions for analysis.
>>> std / sum(std) # doctest:+SKIP
array([0.5769149 , 0.28845742, 0.1346276 ], dtype=float32)
From this result, we can determine that the axes explain approximately
58%, 29%, and 13% of the total variance in the points, respectively.
Let's compare this to the proportions of the known radii of the ellipsoid.
>>> radii / sum(radii)
array([0.6, 0.3, 0.1])
Note how the two ratios are similar, but do not match exactly. This is
because the points of the ellipsoid are prolate and are denser near the
poles. If the points were normally distributed, however, the proportions
would match exactly.
Create an array of normally distributed points scaled along the x-y-z axes.
Use the same scaling as the radii of the ellipsoid from the previous example.
>>> normal_points = rng.normal(size=(1000, 3))
>>> scaled_points = normal_points * radii
>>> axes, std = pv.principal_axes(scaled_points, return_std=True)
>>> axes
array([[-0.99997578, 0.00682346, 0.00136972],
[ 0.00681368, 0.99995213, -0.00702282],
[-0.00141757, -0.00701331, -0.9999744 ]])
Once again, the axes have ones along the diagonal as expected since the
points are already axis-aligned. Now let's examine the standard deviation
and compare the relative proportions.
>>> std
array([5.94466738, 2.89590334, 1.02103169])
>>> std / sum(std)
array([0.60280948, 0.29365444, 0.10353608])
>>> radii / sum(radii)
array([0.6, 0.3, 0.1])
Since the points are normally distributed, the relative proportion of
the standard deviation matches the scaling of the axes almost perfectly.
pyvista.pyvista_ndarray
Python Library Documentation: class pyvista_ndarray in module pyvista.core.pyvista_ndarray
class pyvista_ndarray(pyvista.core.utilities.misc._NoNewAttrMixin, numpy.ndarray)
| pyvista_ndarray(*args, **kwargs) -> '_T'
|
| A ndarray which references the owning dataset and the underlying vtk array.
|
| This array can be acted upon just like a :class:`numpy.ndarray`.
|
| Parameters
| ----------
| array : ArrayLike or :vtk:`vtkAbstractArray`
| Array like.
|
| dataset : DataSet
| Input dataset.
|
| association : pyvista.core.utilities.arrays.FieldAssociation
| Field association.
|
| Examples
| --------
| Return the points of a Sphere as a :class:`pyvista.pyvista_ndarray`.
|
| >>> import pyvista as pv
| >>> mesh = pv.Sphere()
| >>> mesh.points # doctest:+SKIP
| pyvista_ndarray([[-5.5511151e-17, 0.0000000e+00, -5.0000000e-01],
| [ 5.5511151e-17, 0.0000000e+00, 5.0000000e-01],
| [-5.4059509e-02, 0.0000000e+00, -4.9706897e-01],
| ...,
| [-1.5616201e-01, -3.3193260e-02, 4.7382659e-01],
| [-1.0513641e-01, -2.2347433e-02, 4.8831028e-01],
| [-5.2878179e-02, -1.1239604e-02, 4.9706897e-01]],
| dtype=float32)
|
| Method resolution order:
| pyvista_ndarray
| pyvista.core.utilities.misc._NoNewAttrMixin
| numpy.ndarray
| builtins.object
|
| Methods defined here:
|
| __array_finalize__(self: 'pyvista_ndarray', obj: 'npt.NDArray[Any] | None') -> 'None'
| Finalize array (associate with parent metadata).
|
| __array_wrap__(self: 'pyvista_ndarray', out_arr, context=None, return_scalar: 'bool' = False)
| Return a numpy scalar if array is 0d.
|
| See https://github.com/numpy/numpy/issues/5819
|
| __getattr__(self, name: 'str') from pyvista.core._vtk_utilities.VTKObjectWrapperCheckSnakeCase
| Forward unknown attribute requests to VTKArray's __getattr__.
|
| __setitem__(self: 'pyvista_ndarray', key: 'int | NumpyArray[int]', value: 'Any') -> 'None'
| Implement [] set operator.
|
| When the array is changed it triggers "Modified()" which updates
| all upstream objects, including any render windows holding the
| object.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(cls: 'type[pyvista_ndarray]', array: 'ArrayLike[float] | _vtk.vtkAbstractArray', dataset: 'DataSet | _vtk.vtkDataSet | _vtk.VTKObjectWrapper | None' = None, association: 'FieldAssociation' = <FieldAssociation.NONE: 2>) -> 'pyvista_ndarray'
| Allocate the array.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from numpy.ndarray:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __and__(self, value, /)
| Return self&value.
|
| __array__(...)
| a.__array__([dtype], *, copy=None)
|
| For ``dtype`` parameter it returns a new reference to self if
| ``dtype`` is not given or it matches array's data type.
| A new array of provided data type is returned if ``dtype``
| is different from the current data type of the array.
| For ``copy`` parameter it returns a new reference to self if
| ``copy=False`` or ``copy=None`` and copying isn't enforced by ``dtype``
| parameter. The method returns a new array for ``copy=True``, regardless of
| ``dtype`` parameter.
|
| A more detailed explanation of the ``__array__`` interface
| can be found in :ref:`dunder_array.interface`.
|
| __array_function__(...)
|
| __array_namespace__(...)
|
| __array_ufunc__(...)
|
| __bool__(self, /)
| True if self else False
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __complex__(...)
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __copy__(...)
| a.__copy__()
|
| Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
|
| Equivalent to ``a.copy(order='K')``.
|
| __deepcopy__(...)
| a.__deepcopy__(memo, /)
|
| Used if :func:`copy.deepcopy` is called on an array.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __dlpack__(...)
| a.__dlpack__(*, stream=None, max_version=None, dl_device=None, copy=None)
|
| DLPack Protocol: Part of the Array API.
|
| __dlpack_device__(...)
| a.__dlpack_device__()
|
| DLPack Protocol: Part of the Array API.
|
| __eq__(self, value, /)
| Return self==value.
|
| __float__(self, /)
| float(self)
|
| __floordiv__(self, value, /)
| Return self//value.
|
| __format__(...)
| Default object formatter.
|
| Return str(self) if format_spec is empty. Raise TypeError otherwise.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __iadd__(self, value, /)
| Return self+=value.
|
| __iand__(self, value, /)
| Return self&=value.
|
| __ifloordiv__(self, value, /)
| Return self//=value.
|
| __ilshift__(self, value, /)
| Return self<<=value.
|
| __imatmul__(self, value, /)
| Return self@=value.
|
| __imod__(self, value, /)
| Return self%=value.
|
| __imul__(self, value, /)
| Return self*=value.
|
| __index__(self, /)
| Return self converted to an integer, if self is suitable for use as an index into a list.
|
| __int__(self, /)
| int(self)
|
| __invert__(self, /)
| ~self
|
| __ior__(self, value, /)
| Return self|=value.
|
| __ipow__(self, value, /)
| Return self**=value.
|
| __irshift__(self, value, /)
| Return self>>=value.
|
| __isub__(self, value, /)
| Return self-=value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __itruediv__(self, value, /)
| Return self/=value.
|
| __ixor__(self, value, /)
| Return self^=value.
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lshift__(self, value, /)
| Return self<<value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __matmul__(self, value, /)
| Return self@value.
|
| __mod__(self, value, /)
| Return self%value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __neg__(self, /)
| -self
|
| __or__(self, value, /)
| Return self|value.
|
| __pos__(self, /)
| +self
|
| __pow__(self, value, mod=None, /)
| Return pow(self, value, mod).
|
| __radd__(self, value, /)
| Return value+self.
|
| __rand__(self, value, /)
| Return value&self.
|
| __rdivmod__(self, value, /)
| Return divmod(value, self).
|
| __reduce__(...)
| a.__reduce__()
|
| For pickling.
|
| __reduce_ex__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __rfloordiv__(self, value, /)
| Return value//self.
|
| __rlshift__(self, value, /)
| Return value<<self.
|
| __rmatmul__(self, value, /)
| Return value@self.
|
| __rmod__(self, value, /)
| Return value%self.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __ror__(self, value, /)
| Return value|self.
|
| __rpow__(self, value, mod=None, /)
| Return pow(value, self, mod).
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| __rsub__(self, value, /)
| Return value-self.
|
| __rtruediv__(self, value, /)
| Return value/self.
|
| __rxor__(self, value, /)
| Return value^self.
|
| __setstate__(...)
| a.__setstate__(state, /)
|
| For unpickling.
|
| The `state` argument must be a sequence that contains the following
| elements:
|
| Parameters
| ----------
| version : int
| optional pickle version. If omitted defaults to 0.
| shape : tuple
| dtype : data-type
| isFortran : bool
| rawdata : string or list
| a binary string with the data (or a list if 'a' is an object array)
|
| __sizeof__(...)
| Size of object in memory, in bytes.
|
| __str__(self, /)
| Return str(self).
|
| __sub__(self, value, /)
| Return self-value.
|
| __truediv__(self, value, /)
| Return self/value.
|
| __xor__(self, value, /)
| Return self^value.
|
| all(...)
| a.all(axis=None, out=None, keepdims=False, *, where=True)
|
| Returns True if all elements evaluate to True.
|
| Refer to `numpy.all` for full documentation.
|
| See Also
| --------
| numpy.all : equivalent function
|
| any(...)
| a.any(axis=None, out=None, keepdims=False, *, where=True)
|
| Returns True if any of the elements of `a` evaluate to True.
|
| Refer to `numpy.any` for full documentation.
|
| See Also
| --------
| numpy.any : equivalent function
|
| argmax(...)
| a.argmax(axis=None, out=None, *, keepdims=False)
|
| Return indices of the maximum values along the given axis.
|
| Refer to `numpy.argmax` for full documentation.
|
| See Also
| --------
| numpy.argmax : equivalent function
|
| argmin(...)
| a.argmin(axis=None, out=None, *, keepdims=False)
|
| Return indices of the minimum values along the given axis.
|
| Refer to `numpy.argmin` for detailed documentation.
|
| See Also
| --------
| numpy.argmin : equivalent function
|
| argpartition(...)
| a.argpartition(kth, axis=-1, kind='introselect', order=None)
|
| Returns the indices that would partition this array.
|
| Refer to `numpy.argpartition` for full documentation.
|
| .. versionadded:: 1.8.0
|
| See Also
| --------
| numpy.argpartition : equivalent function
|
| argsort(...)
| a.argsort(axis=-1, kind=None, order=None)
|
| Returns the indices that would sort this array.
|
| Refer to `numpy.argsort` for full documentation.
|
| See Also
| --------
| numpy.argsort : equivalent function
|
| astype(...)
| a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
|
| Copy of the array, cast to a specified type.
|
| Parameters
| ----------
| dtype : str or dtype
| Typecode or data-type to which the array is cast.
| order : {'C', 'F', 'A', 'K'}, optional
| Controls the memory layout order of the result.
| 'C' means C order, 'F' means Fortran order, 'A'
| means 'F' order if all the arrays are Fortran contiguous,
| 'C' order otherwise, and 'K' means as close to the
| order the array elements appear in memory as possible.
| Default is 'K'.
| casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
| Controls what kind of data casting may occur. Defaults to 'unsafe'
| for backwards compatibility.
|
| * 'no' means the data types should not be cast at all.
| * 'equiv' means only byte-order changes are allowed.
| * 'safe' means only casts which can preserve values are allowed.
| * 'same_kind' means only safe casts or casts within a kind,
| like float64 to float32, are allowed.
| * 'unsafe' means any data conversions may be done.
| subok : bool, optional
| If True, then sub-classes will be passed-through (default), otherwise
| the returned array will be forced to be a base-class array.
| copy : bool, optional
| By default, astype always returns a newly allocated array. If this
| is set to false, and the `dtype`, `order`, and `subok`
| requirements are satisfied, the input array is returned instead
| of a copy.
|
| Returns
| -------
| arr_t : ndarray
| Unless `copy` is False and the other conditions for returning the input
| array are satisfied (see description for `copy` input parameter), `arr_t`
| is a new array of the same shape as the input array, with dtype, order
| given by `dtype`, `order`.
|
| Notes
| -----
| .. versionchanged:: 1.17.0
| Casting between a simple data type and a structured one is possible only
| for "unsafe" casting. Casting to multiple fields is allowed, but
| casting from multiple fields is not.
|
| .. versionchanged:: 1.9.0
| Casting from numeric to string types in 'safe' casting mode requires
| that the string dtype length is long enough to store the max
| integer/float value converted.
|
| Raises
| ------
| ComplexWarning
| When casting from complex to float or int. To avoid this,
| one should use ``a.real.astype(t)``.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.array([1, 2, 2.5])
| >>> x
| array([1. , 2. , 2.5])
|
| >>> x.astype(int)
| array([1, 2, 2])
|
| byteswap(...)
| a.byteswap(inplace=False)
|
| Swap the bytes of the array elements
|
| Toggle between low-endian and big-endian data representation by
| returning a byteswapped array, optionally swapped in-place.
| Arrays of byte-strings are not swapped. The real and imaginary
| parts of a complex number are swapped individually.
|
| Parameters
| ----------
| inplace : bool, optional
| If ``True``, swap bytes in-place, default is ``False``.
|
| Returns
| -------
| out : ndarray
| The byteswapped array. If `inplace` is ``True``, this is
| a view to self.
|
| Examples
| --------
| >>> import numpy as np
| >>> A = np.array([1, 256, 8755], dtype=np.int16)
| >>> list(map(hex, A))
| ['0x1', '0x100', '0x2233']
| >>> A.byteswap(inplace=True)
| array([ 256, 1, 13090], dtype=int16)
| >>> list(map(hex, A))
| ['0x100', '0x1', '0x3322']
|
| Arrays of byte-strings are not swapped
|
| >>> A = np.array([b'ceg', b'fac'])
| >>> A.byteswap()
| array([b'ceg', b'fac'], dtype='|S3')
|
| ``A.view(A.dtype.newbyteorder()).byteswap()`` produces an array with
| the same values but different representation in memory
|
| >>> A = np.array([1, 2, 3])
| >>> A.view(np.uint8)
| array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
| 0, 0], dtype=uint8)
| >>> A.view(A.dtype.newbyteorder()).byteswap(inplace=True)
| array([1, 2, 3])
| >>> A.view(np.uint8)
| array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
| 0, 3], dtype=uint8)
|
| choose(...)
| a.choose(choices, out=None, mode='raise')
|
| Use an index array to construct a new array from a set of choices.
|
| Refer to `numpy.choose` for full documentation.
|
| See Also
| --------
| numpy.choose : equivalent function
|
| clip(...)
| a.clip(min=None, max=None, out=None, **kwargs)
|
| Return an array whose values are limited to ``[min, max]``.
| One of max or min must be given.
|
| Refer to `numpy.clip` for full documentation.
|
| See Also
| --------
| numpy.clip : equivalent function
|
| compress(...)
| a.compress(condition, axis=None, out=None)
|
| Return selected slices of this array along given axis.
|
| Refer to `numpy.compress` for full documentation.
|
| See Also
| --------
| numpy.compress : equivalent function
|
| conj(...)
| a.conj()
|
| Complex-conjugate all elements.
|
| Refer to `numpy.conjugate` for full documentation.
|
| See Also
| --------
| numpy.conjugate : equivalent function
|
| conjugate(...)
| a.conjugate()
|
| Return the complex conjugate, element-wise.
|
| Refer to `numpy.conjugate` for full documentation.
|
| See Also
| --------
| numpy.conjugate : equivalent function
|
| copy(...)
| a.copy(order='C')
|
| Return a copy of the array.
|
| Parameters
| ----------
| order : {'C', 'F', 'A', 'K'}, optional
| Controls the memory layout of the copy. 'C' means C-order,
| 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
| 'C' otherwise. 'K' means match the layout of `a` as closely
| as possible. (Note that this function and :func:`numpy.copy` are very
| similar but have different default values for their order=
| arguments, and this function always passes sub-classes through.)
|
| See also
| --------
| numpy.copy : Similar function with different default behavior
| numpy.copyto
|
| Notes
| -----
| This function is the preferred method for creating an array copy. The
| function :func:`numpy.copy` is similar, but it defaults to using order 'K',
| and will not pass sub-classes through by default.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.array([[1,2,3],[4,5,6]], order='F')
|
| >>> y = x.copy()
|
| >>> x.fill(0)
|
| >>> x
| array([[0, 0, 0],
| [0, 0, 0]])
|
| >>> y
| array([[1, 2, 3],
| [4, 5, 6]])
|
| >>> y.flags['C_CONTIGUOUS']
| True
|
| For arrays containing Python objects (e.g. dtype=object),
| the copy is a shallow one. The new array will contain the
| same object which may lead to surprises if that object can
| be modified (is mutable):
|
| >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
| >>> b = a.copy()
| >>> b[2][0] = 10
| >>> a
| array([1, 'm', list([10, 3, 4])], dtype=object)
|
| To ensure all elements within an ``object`` array are copied,
| use `copy.deepcopy`:
|
| >>> import copy
| >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
| >>> c = copy.deepcopy(a)
| >>> c[2][0] = 10
| >>> c
| array([1, 'm', list([10, 3, 4])], dtype=object)
| >>> a
| array([1, 'm', list([2, 3, 4])], dtype=object)
|
| cumprod(...)
| a.cumprod(axis=None, dtype=None, out=None)
|
| Return the cumulative product of the elements along the given axis.
|
| Refer to `numpy.cumprod` for full documentation.
|
| See Also
| --------
| numpy.cumprod : equivalent function
|
| cumsum(...)
| a.cumsum(axis=None, dtype=None, out=None)
|
| Return the cumulative sum of the elements along the given axis.
|
| Refer to `numpy.cumsum` for full documentation.
|
| See Also
| --------
| numpy.cumsum : equivalent function
|
| diagonal(...)
| a.diagonal(offset=0, axis1=0, axis2=1)
|
| Return specified diagonals. In NumPy 1.9 the returned array is a
| read-only view instead of a copy as in previous NumPy versions. In
| a future version the read-only restriction will be removed.
|
| Refer to :func:`numpy.diagonal` for full documentation.
|
| See Also
| --------
| numpy.diagonal : equivalent function
|
| dot(...)
|
| dump(...)
| a.dump(file)
|
| Dump a pickle of the array to the specified file.
| The array can be read back with pickle.load or numpy.load.
|
| Parameters
| ----------
| file : str or Path
| A string naming the dump file.
|
| .. versionchanged:: 1.17.0
| `pathlib.Path` objects are now accepted.
|
| dumps(...)
| a.dumps()
|
| Returns the pickle of the array as a string.
| pickle.loads will convert the string back to an array.
|
| Parameters
| ----------
| None
|
| fill(...)
| a.fill(value)
|
| Fill the array with a scalar value.
|
| Parameters
| ----------
| value : scalar
| All elements of `a` will be assigned this value.
|
| Examples
| --------
| >>> import numpy as np
| >>> a = np.array([1, 2])
| >>> a.fill(0)
| >>> a
| array([0, 0])
| >>> a = np.empty(2)
| >>> a.fill(1)
| >>> a
| array([1., 1.])
|
| Fill expects a scalar value and always behaves the same as assigning
| to a single array element. The following is a rare example where this
| distinction is important:
|
| >>> a = np.array([None, None], dtype=object)
| >>> a[0] = np.array(3)
| >>> a
| array([array(3), None], dtype=object)
| >>> a.fill(np.array(3))
| >>> a
| array([array(3), array(3)], dtype=object)
|
| Where other forms of assignments will unpack the array being assigned:
|
| >>> a[...] = np.array(3)
| >>> a
| array([3, 3], dtype=object)
|
| flatten(...)
| a.flatten(order='C')
|
| Return a copy of the array collapsed into one dimension.
|
| Parameters
| ----------
| order : {'C', 'F', 'A', 'K'}, optional
| 'C' means to flatten in row-major (C-style) order.
| 'F' means to flatten in column-major (Fortran-
| style) order. 'A' means to flatten in column-major
| order if `a` is Fortran *contiguous* in memory,
| row-major order otherwise. 'K' means to flatten
| `a` in the order the elements occur in memory.
| The default is 'C'.
|
| Returns
| -------
| y : ndarray
| A copy of the input array, flattened to one dimension.
|
| See Also
| --------
| ravel : Return a flattened array.
| flat : A 1-D flat iterator over the array.
|
| Examples
| --------
| >>> import numpy as np
| >>> a = np.array([[1,2], [3,4]])
| >>> a.flatten()
| array([1, 2, 3, 4])
| >>> a.flatten('F')
| array([1, 3, 2, 4])
|
| getfield(...)
| a.getfield(dtype, offset=0)
|
| Returns a field of the given array as a certain type.
|
| A field is a view of the array data with a given data-type. The values in
| the view are determined by the given type and the offset into the current
| array in bytes. The offset needs to be such that the view dtype fits in the
| array dtype; for example an array of dtype complex128 has 16-byte elements.
| If taking a view with a 32-bit integer (4 bytes), the offset needs to be
| between 0 and 12 bytes.
|
| Parameters
| ----------
| dtype : str or dtype
| The data type of the view. The dtype size of the view can not be larger
| than that of the array itself.
| offset : int
| Number of bytes to skip before beginning the element view.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.diag([1.+1.j]*2)
| >>> x[1, 1] = 2 + 4.j
| >>> x
| array([[1.+1.j, 0.+0.j],
| [0.+0.j, 2.+4.j]])
| >>> x.getfield(np.float64)
| array([[1., 0.],
| [0., 2.]])
|
| By choosing an offset of 8 bytes we can select the complex part of the
| array for our view:
|
| >>> x.getfield(np.float64, offset=8)
| array([[1., 0.],
| [0., 4.]])
|
| item(...)
| a.item(*args)
|
| Copy an element of an array to a standard Python scalar and return it.
|
| Parameters
| ----------
| \*args : Arguments (variable number and type)
|
| * none: in this case, the method only works for arrays
| with one element (`a.size == 1`), which element is
| copied into a standard Python scalar object and returned.
|
| * int_type: this argument is interpreted as a flat index into
| the array, specifying which element to copy and return.
|
| * tuple of int_types: functions as does a single int_type argument,
| except that the argument is interpreted as an nd-index into the
| array.
|
| Returns
| -------
| z : Standard Python scalar object
| A copy of the specified element of the array as a suitable
| Python scalar
|
| Notes
| -----
| When the data type of `a` is longdouble or clongdouble, item() returns
| a scalar array object because there is no available Python scalar that
| would not lose information. Void arrays return a buffer object for item(),
| unless fields are defined, in which case a tuple is returned.
|
| `item` is very similar to a[args], except, instead of an array scalar,
| a standard Python scalar is returned. This can be useful for speeding up
| access to elements of the array and doing arithmetic on elements of the
| array using Python's optimized math.
|
| Examples
| --------
| >>> import numpy as np
| >>> np.random.seed(123)
| >>> x = np.random.randint(9, size=(3, 3))
| >>> x
| array([[2, 2, 6],
| [1, 3, 6],
| [1, 0, 1]])
| >>> x.item(3)
| 1
| >>> x.item(7)
| 0
| >>> x.item((0, 1))
| 2
| >>> x.item((2, 2))
| 1
|
| For an array with object dtype, elements are returned as-is.
|
| >>> a = np.array([np.int64(1)], dtype=object)
| >>> a.item() #return np.int64
| np.int64(1)
|
| max(...)
| a.max(axis=None, out=None, keepdims=False, initial=<no value>, where=True)
|
| Return the maximum along a given axis.
|
| Refer to `numpy.amax` for full documentation.
|
| See Also
| --------
| numpy.amax : equivalent function
|
| mean(...)
| a.mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True)
|
| Returns the average of the array elements along given axis.
|
| Refer to `numpy.mean` for full documentation.
|
| See Also
| --------
| numpy.mean : equivalent function
|
| min(...)
| a.min(axis=None, out=None, keepdims=False, initial=<no value>, where=True)
|
| Return the minimum along a given axis.
|
| Refer to `numpy.amin` for full documentation.
|
| See Also
| --------
| numpy.amin : equivalent function
|
| nonzero(...)
| a.nonzero()
|
| Return the indices of the elements that are non-zero.
|
| Refer to `numpy.nonzero` for full documentation.
|
| See Also
| --------
| numpy.nonzero : equivalent function
|
| partition(...)
| a.partition(kth, axis=-1, kind='introselect', order=None)
|
| Partially sorts the elements in the array in such a way that the value of
| the element in k-th position is in the position it would be in a sorted
| array. In the output array, all elements smaller than the k-th element
| are located to the left of this element and all equal or greater are
| located to its right. The ordering of the elements in the two partitions
| on the either side of the k-th element in the output array is undefined.
|
| .. versionadded:: 1.8.0
|
| Parameters
| ----------
| kth : int or sequence of ints
| Element index to partition by. The kth element value will be in its
| final sorted position and all smaller elements will be moved before it
| and all equal or greater elements behind it.
| The order of all elements in the partitions is undefined.
| If provided with a sequence of kth it will partition all elements
| indexed by kth of them into their sorted position at once.
|
| .. deprecated:: 1.22.0
| Passing booleans as index is deprecated.
| axis : int, optional
| Axis along which to sort. Default is -1, which means sort along the
| last axis.
| kind : {'introselect'}, optional
| Selection algorithm. Default is 'introselect'.
| order : str or list of str, optional
| When `a` is an array with fields defined, this argument specifies
| which fields to compare first, second, etc. A single field can
| be specified as a string, and not all fields need to be specified,
| but unspecified fields will still be used, in the order in which
| they come up in the dtype, to break ties.
|
| See Also
| --------
| numpy.partition : Return a partitioned copy of an array.
| argpartition : Indirect partition.
| sort : Full sort.
|
| Notes
| -----
| See ``np.partition`` for notes on the different algorithms.
|
| Examples
| --------
| >>> import numpy as np
| >>> a = np.array([3, 4, 2, 1])
| >>> a.partition(3)
| >>> a
| array([2, 1, 3, 4]) # may vary
|
| >>> a.partition((1, 3))
| >>> a
| array([1, 2, 3, 4])
|
| prod(...)
| a.prod(axis=None, dtype=None, out=None, keepdims=False,
| initial=1, where=True)
|
| Return the product of the array elements over the given axis
|
| Refer to `numpy.prod` for full documentation.
|
| See Also
| --------
| numpy.prod : equivalent function
|
| put(...)
| a.put(indices, values, mode='raise')
|
| Set ``a.flat[n] = values[n]`` for all `n` in indices.
|
| Refer to `numpy.put` for full documentation.
|
| See Also
| --------
| numpy.put : equivalent function
|
| ravel(...)
| a.ravel([order])
|
| Return a flattened array.
|
| Refer to `numpy.ravel` for full documentation.
|
| See Also
| --------
| numpy.ravel : equivalent function
|
| ndarray.flat : a flat iterator on the array.
|
| repeat(...)
| a.repeat(repeats, axis=None)
|
| Repeat elements of an array.
|
| Refer to `numpy.repeat` for full documentation.
|
| See Also
| --------
| numpy.repeat : equivalent function
|
| reshape(...)
| a.reshape(shape, /, *, order='C', copy=None)
|
| Returns an array containing the same data with a new shape.
|
| Refer to `numpy.reshape` for full documentation.
|
| See Also
| --------
| numpy.reshape : equivalent function
|
| Notes
| -----
| Unlike the free function `numpy.reshape`, this method on `ndarray` allows
| the elements of the shape parameter to be passed in as separate arguments.
| For example, ``a.reshape(10, 11)`` is equivalent to
| ``a.reshape((10, 11))``.
|
| resize(...)
| a.resize(new_shape, refcheck=True)
|
| Change shape and size of array in-place.
|
| Parameters
| ----------
| new_shape : tuple of ints, or `n` ints
| Shape of resized array.
| refcheck : bool, optional
| If False, reference count will not be checked. Default is True.
|
| Returns
| -------
| None
|
| Raises
| ------
| ValueError
| If `a` does not own its own data or references or views to it exist,
| and the data memory must be changed.
| PyPy only: will always raise if the data memory must be changed, since
| there is no reliable way to determine if references or views to it
| exist.
|
| SystemError
| If the `order` keyword argument is specified. This behaviour is a
| bug in NumPy.
|
| See Also
| --------
| resize : Return a new array with the specified shape.
|
| Notes
| -----
| This reallocates space for the data area if necessary.
|
| Only contiguous arrays (data elements consecutive in memory) can be
| resized.
|
| The purpose of the reference count check is to make sure you
| do not use this array as a buffer for another Python object and then
| reallocate the memory. However, reference counts can increase in
| other ways so if you are sure that you have not shared the memory
| for this array with another Python object, then you may safely set
| `refcheck` to False.
|
| Examples
| --------
| Shrinking an array: array is flattened (in the order that the data are
| stored in memory), resized, and reshaped:
|
| >>> import numpy as np
|
| >>> a = np.array([[0, 1], [2, 3]], order='C')
| >>> a.resize((2, 1))
| >>> a
| array([[0],
| [1]])
|
| >>> a = np.array([[0, 1], [2, 3]], order='F')
| >>> a.resize((2, 1))
| >>> a
| array([[0],
| [2]])
|
| Enlarging an array: as above, but missing entries are filled with zeros:
|
| >>> b = np.array([[0, 1], [2, 3]])
| >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
| >>> b
| array([[0, 1, 2],
| [3, 0, 0]])
|
| Referencing an array prevents resizing...
|
| >>> c = a
| >>> a.resize((1, 1))
| Traceback (most recent call last):
| ...
| ValueError: cannot resize an array that references or is referenced ...
|
| Unless `refcheck` is False:
|
| >>> a.resize((1, 1), refcheck=False)
| >>> a
| array([[0]])
| >>> c
| array([[0]])
|
| round(...)
| a.round(decimals=0, out=None)
|
| Return `a` with each element rounded to the given number of decimals.
|
| Refer to `numpy.around` for full documentation.
|
| See Also
| --------
| numpy.around : equivalent function
|
| searchsorted(...)
| a.searchsorted(v, side='left', sorter=None)
|
| Find indices where elements of v should be inserted in a to maintain order.
|
| For full documentation, see `numpy.searchsorted`
|
| See Also
| --------
| numpy.searchsorted : equivalent function
|
| setfield(...)
| a.setfield(val, dtype, offset=0)
|
| Put a value into a specified place in a field defined by a data-type.
|
| Place `val` into `a`'s field defined by `dtype` and beginning `offset`
| bytes into the field.
|
| Parameters
| ----------
| val : object
| Value to be placed in field.
| dtype : dtype object
| Data-type of the field in which to place `val`.
| offset : int, optional
| The number of bytes into the field at which to place `val`.
|
| Returns
| -------
| None
|
| See Also
| --------
| getfield
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.eye(3)
| >>> x.getfield(np.float64)
| array([[1., 0., 0.],
| [0., 1., 0.],
| [0., 0., 1.]])
| >>> x.setfield(3, np.int32)
| >>> x.getfield(np.int32)
| array([[3, 3, 3],
| [3, 3, 3],
| [3, 3, 3]], dtype=int32)
| >>> x
| array([[1.0e+000, 1.5e-323, 1.5e-323],
| [1.5e-323, 1.0e+000, 1.5e-323],
| [1.5e-323, 1.5e-323, 1.0e+000]])
| >>> x.setfield(np.eye(3), np.int32)
| >>> x
| array([[1., 0., 0.],
| [0., 1., 0.],
| [0., 0., 1.]])
|
| setflags(...)
| a.setflags(write=None, align=None, uic=None)
|
| Set array flags WRITEABLE, ALIGNED, WRITEBACKIFCOPY,
| respectively.
|
| These Boolean-valued flags affect how numpy interprets the memory
| area used by `a` (see Notes below). The ALIGNED flag can only
| be set to True if the data is actually aligned according to the type.
| The WRITEBACKIFCOPY flag can never be set
| to True. The flag WRITEABLE can only be set to True if the array owns its
| own memory, or the ultimate owner of the memory exposes a writeable buffer
| interface, or is a string. (The exception for string is made so that
| unpickling can be done without copying memory.)
|
| Parameters
| ----------
| write : bool, optional
| Describes whether or not `a` can be written to.
| align : bool, optional
| Describes whether or not `a` is aligned properly for its type.
| uic : bool, optional
| Describes whether or not `a` is a copy of another "base" array.
|
| Notes
| -----
| Array flags provide information about how the memory area used
| for the array is to be interpreted. There are 7 Boolean flags
| in use, only three of which can be changed by the user:
| WRITEBACKIFCOPY, WRITEABLE, and ALIGNED.
|
| WRITEABLE (W) the data area can be written to;
|
| ALIGNED (A) the data and strides are aligned appropriately for the hardware
| (as determined by the compiler);
|
| WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
| by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
| called, the base array will be updated with the contents of this array.
|
| All flags can be accessed using the single (upper case) letter as well
| as the full name.
|
| Examples
| --------
| >>> import numpy as np
| >>> y = np.array([[3, 1, 7],
| ... [2, 0, 0],
| ... [8, 5, 9]])
| >>> y
| array([[3, 1, 7],
| [2, 0, 0],
| [8, 5, 9]])
| >>> y.flags
| C_CONTIGUOUS : True
| F_CONTIGUOUS : False
| OWNDATA : True
| WRITEABLE : True
| ALIGNED : True
| WRITEBACKIFCOPY : False
| >>> y.setflags(write=0, align=0)
| >>> y.flags
| C_CONTIGUOUS : True
| F_CONTIGUOUS : False
| OWNDATA : True
| WRITEABLE : False
| ALIGNED : False
| WRITEBACKIFCOPY : False
| >>> y.setflags(uic=1)
| Traceback (most recent call last):
| File "<stdin>", line 1, in <module>
| ValueError: cannot set WRITEBACKIFCOPY flag to True
|
| sort(...)
| a.sort(axis=-1, kind=None, order=None)
|
| Sort an array in-place. Refer to `numpy.sort` for full documentation.
|
| Parameters
| ----------
| axis : int, optional
| Axis along which to sort. Default is -1, which means sort along the
| last axis.
| kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
| Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
| and 'mergesort' use timsort under the covers and, in general, the
| actual implementation will vary with datatype. The 'mergesort' option
| is retained for backwards compatibility.
|
| .. versionchanged:: 1.15.0
| The 'stable' option was added.
|
| order : str or list of str, optional
| When `a` is an array with fields defined, this argument specifies
| which fields to compare first, second, etc. A single field can
| be specified as a string, and not all fields need be specified,
| but unspecified fields will still be used, in the order in which
| they come up in the dtype, to break ties.
|
| See Also
| --------
| numpy.sort : Return a sorted copy of an array.
| numpy.argsort : Indirect sort.
| numpy.lexsort : Indirect stable sort on multiple keys.
| numpy.searchsorted : Find elements in sorted array.
| numpy.partition: Partial sort.
|
| Notes
| -----
| See `numpy.sort` for notes on the different sorting algorithms.
|
| Examples
| --------
| >>> import numpy as np
| >>> a = np.array([[1,4], [3,1]])
| >>> a.sort(axis=1)
| >>> a
| array([[1, 4],
| [1, 3]])
| >>> a.sort(axis=0)
| >>> a
| array([[1, 3],
| [1, 4]])
|
| Use the `order` keyword to specify a field to use when sorting a
| structured array:
|
| >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
| >>> a.sort(order='y')
| >>> a
| array([(b'c', 1), (b'a', 2)],
| dtype=[('x', 'S1'), ('y', '<i8')])
|
| squeeze(...)
| a.squeeze(axis=None)
|
| Remove axes of length one from `a`.
|
| Refer to `numpy.squeeze` for full documentation.
|
| See Also
| --------
| numpy.squeeze : equivalent function
|
| std(...)
| a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)
|
| Returns the standard deviation of the array elements along given axis.
|
| Refer to `numpy.std` for full documentation.
|
| See Also
| --------
| numpy.std : equivalent function
|
| sum(...)
| a.sum(axis=None, dtype=None, out=None, keepdims=False, initial=0, where=True)
|
| Return the sum of the array elements over the given axis.
|
| Refer to `numpy.sum` for full documentation.
|
| See Also
| --------
| numpy.sum : equivalent function
|
| swapaxes(...)
| a.swapaxes(axis1, axis2)
|
| Return a view of the array with `axis1` and `axis2` interchanged.
|
| Refer to `numpy.swapaxes` for full documentation.
|
| See Also
| --------
| numpy.swapaxes : equivalent function
|
| take(...)
| a.take(indices, axis=None, out=None, mode='raise')
|
| Return an array formed from the elements of `a` at the given indices.
|
| Refer to `numpy.take` for full documentation.
|
| See Also
| --------
| numpy.take : equivalent function
|
| to_device(...)
|
| tobytes(...)
| a.tobytes(order='C')
|
| Construct Python bytes containing the raw data bytes in the array.
|
| Constructs Python bytes showing a copy of the raw contents of
| data memory. The bytes object is produced in C-order by default.
| This behavior is controlled by the ``order`` parameter.
|
| .. versionadded:: 1.9.0
|
| Parameters
| ----------
| order : {'C', 'F', 'A'}, optional
| Controls the memory layout of the bytes object. 'C' means C-order,
| 'F' means F-order, 'A' (short for *Any*) means 'F' if `a` is
| Fortran contiguous, 'C' otherwise. Default is 'C'.
|
| Returns
| -------
| s : bytes
| Python bytes exhibiting a copy of `a`'s raw data.
|
| See also
| --------
| frombuffer
| Inverse of this operation, construct a 1-dimensional array from Python
| bytes.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.array([[0, 1], [2, 3]], dtype='<u2')
| >>> x.tobytes()
| b'\x00\x00\x01\x00\x02\x00\x03\x00'
| >>> x.tobytes('C') == x.tobytes()
| True
| >>> x.tobytes('F')
| b'\x00\x00\x02\x00\x01\x00\x03\x00'
|
| tofile(...)
| a.tofile(fid, sep="", format="%s")
|
| Write array to a file as text or binary (default).
|
| Data is always written in 'C' order, independent of the order of `a`.
| The data produced by this method can be recovered using the function
| fromfile().
|
| Parameters
| ----------
| fid : file or str or Path
| An open file object, or a string containing a filename.
|
| .. versionchanged:: 1.17.0
| `pathlib.Path` objects are now accepted.
|
| sep : str
| Separator between array items for text output.
| If "" (empty), a binary file is written, equivalent to
| ``file.write(a.tobytes())``.
| format : str
| Format string for text file output.
| Each entry in the array is formatted to text by first converting
| it to the closest Python type, and then using "format" % item.
|
| Notes
| -----
| This is a convenience function for quick storage of array data.
| Information on endianness and precision is lost, so this method is not a
| good choice for files intended to archive data or transport data between
| machines with different endianness. Some of these problems can be overcome
| by outputting the data as text files, at the expense of speed and file
| size.
|
| When fid is a file object, array contents are directly written to the
| file, bypassing the file object's ``write`` method. As a result, tofile
| cannot be used with files objects supporting compression (e.g., GzipFile)
| or file-like objects that do not support ``fileno()`` (e.g., BytesIO).
|
| tolist(...)
| a.tolist()
|
| Return the array as an ``a.ndim``-levels deep nested list of Python scalars.
|
| Return a copy of the array data as a (nested) Python list.
| Data items are converted to the nearest compatible builtin Python type, via
| the `~numpy.ndarray.item` function.
|
| If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will
| not be a list at all, but a simple Python scalar.
|
| Parameters
| ----------
| none
|
| Returns
| -------
| y : object, or list of object, or list of list of object, or ...
| The possibly nested list of array elements.
|
| Notes
| -----
| The array may be recreated via ``a = np.array(a.tolist())``, although this
| may sometimes lose precision.
|
| Examples
| --------
| For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``,
| except that ``tolist`` changes numpy scalars to Python scalars:
|
| >>> import numpy as np
| >>> a = np.uint32([1, 2])
| >>> a_list = list(a)
| >>> a_list
| [1, 2]
| >>> type(a_list[0])
| <class 'numpy.uint32'>
| >>> a_tolist = a.tolist()
| >>> a_tolist
| [1, 2]
| >>> type(a_tolist[0])
| <class 'int'>
|
| Additionally, for a 2D array, ``tolist`` applies recursively:
|
| >>> a = np.array([[1, 2], [3, 4]])
| >>> list(a)
| [array([1, 2]), array([3, 4])]
| >>> a.tolist()
| [[1, 2], [3, 4]]
|
| The base case for this recursion is a 0D array:
|
| >>> a = np.array(1)
| >>> list(a)
| Traceback (most recent call last):
| ...
| TypeError: iteration over a 0-d array
| >>> a.tolist()
| 1
|
| tostring(...)
| a.tostring(order='C')
|
| A compatibility alias for `~ndarray.tobytes`, with exactly the same
| behavior.
|
| Despite its name, it returns :class:`bytes` not :class:`str`\ s.
|
| .. deprecated:: 1.19.0
|
| trace(...)
| a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
|
| Return the sum along diagonals of the array.
|
| Refer to `numpy.trace` for full documentation.
|
| See Also
| --------
| numpy.trace : equivalent function
|
| transpose(...)
| a.transpose(*axes)
|
| Returns a view of the array with axes transposed.
|
| Refer to `numpy.transpose` for full documentation.
|
| Parameters
| ----------
| axes : None, tuple of ints, or `n` ints
|
| * None or no argument: reverses the order of the axes.
|
| * tuple of ints: `i` in the `j`-th place in the tuple means that the
| array's `i`-th axis becomes the transposed array's `j`-th axis.
|
| * `n` ints: same as an n-tuple of the same ints (this form is
| intended simply as a "convenience" alternative to the tuple form).
|
| Returns
| -------
| p : ndarray
| View of the array with its axes suitably permuted.
|
| See Also
| --------
| transpose : Equivalent function.
| ndarray.T : Array property returning the array transposed.
| ndarray.reshape : Give a new shape to an array without changing its data.
|
| Examples
| --------
| >>> import numpy as np
| >>> a = np.array([[1, 2], [3, 4]])
| >>> a
| array([[1, 2],
| [3, 4]])
| >>> a.transpose()
| array([[1, 3],
| [2, 4]])
| >>> a.transpose((1, 0))
| array([[1, 3],
| [2, 4]])
| >>> a.transpose(1, 0)
| array([[1, 3],
| [2, 4]])
|
| >>> a = np.array([1, 2, 3, 4])
| >>> a
| array([1, 2, 3, 4])
| >>> a.transpose()
| array([1, 2, 3, 4])
|
| var(...)
| a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)
|
| Returns the variance of the array elements, along given axis.
|
| Refer to `numpy.var` for full documentation.
|
| See Also
| --------
| numpy.var : equivalent function
|
| view(...)
| a.view([dtype][, type])
|
| New view of array with the same data.
|
| .. note::
| Passing None for ``dtype`` is different from omitting the parameter,
| since the former invokes ``dtype(None)`` which is an alias for
| ``dtype('float64')``.
|
| Parameters
| ----------
| dtype : data-type or ndarray sub-class, optional
| Data-type descriptor of the returned view, e.g., float32 or int16.
| Omitting it results in the view having the same data-type as `a`.
| This argument can also be specified as an ndarray sub-class, which
| then specifies the type of the returned object (this is equivalent to
| setting the ``type`` parameter).
| type : Python type, optional
| Type of the returned view, e.g., ndarray or matrix. Again, omission
| of the parameter results in type preservation.
|
| Notes
| -----
| ``a.view()`` is used two different ways:
|
| ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
| of the array's memory with a different data-type. This can cause a
| reinterpretation of the bytes of memory.
|
| ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
| returns an instance of `ndarray_subclass` that looks at the same array
| (same shape, dtype, etc.) This does not cause a reinterpretation of the
| memory.
|
| For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
| bytes per entry than the previous dtype (for example, converting a regular
| array to a structured array), then the last axis of ``a`` must be
| contiguous. This axis will be resized in the result.
|
| .. versionchanged:: 1.23.0
| Only the last axis needs to be contiguous. Previously, the entire array
| had to be C-contiguous.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.array([(-1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
|
| Viewing array data using a different type and dtype:
|
| >>> nonneg = np.dtype([("a", np.uint8), ("b", np.uint8)])
| >>> y = x.view(dtype=nonneg, type=np.recarray)
| >>> x["a"]
| array([-1], dtype=int8)
| >>> y.a
| array([255], dtype=uint8)
|
| Creating a view on a structured array so it can be used in calculations
|
| >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
| >>> xv = x.view(dtype=np.int8).reshape(-1,2)
| >>> xv
| array([[1, 2],
| [3, 4]], dtype=int8)
| >>> xv.mean(0)
| array([2., 3.])
|
| Making changes to the view changes the underlying array
|
| >>> xv[0,1] = 20
| >>> x
| array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')])
|
| Using a view to convert an array to a recarray:
|
| >>> z = x.view(np.recarray)
| >>> z.a
| array([1, 3], dtype=int8)
|
| Views share data:
|
| >>> x[0] = (9, 10)
| >>> z[0]
| np.record((9, 10), dtype=[('a', 'i1'), ('b', 'i1')])
|
| Views that change the dtype size (bytes per entry) should normally be
| avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
|
| >>> x = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int16)
| >>> y = x[:, ::2]
| >>> y
| array([[1, 3],
| [4, 6]], dtype=int16)
| >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
| Traceback (most recent call last):
| ...
| ValueError: To change to a dtype of a different size, the last axis must be contiguous
| >>> z = y.copy()
| >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
| array([[(1, 3)],
| [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])
|
| However, views that change dtype are totally fine for arrays with a
| contiguous last axis, even if the rest of the axes are not C-contiguous:
|
| >>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
| >>> x.transpose(1, 0, 2).view(np.int16)
| array([[[ 256, 770],
| [3340, 3854]],
| <BLANKLINE>
| [[1284, 1798],
| [4368, 4882]],
| <BLANKLINE>
| [[2312, 2826],
| [5396, 5910]]], dtype=int16)
|
| ----------------------------------------------------------------------
| Class methods inherited from numpy.ndarray:
|
| __class_getitem__(...)
| a.__class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.ndarray` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.ndarray` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.ndarray[Any, np.dtype[Any]]
| numpy.ndarray[typing.Any, numpy.dtype[typing.Any]]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
| numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`
| w.r.t. its `dtype.type <numpy.dtype.type>`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from numpy.ndarray:
|
| T
| View of the transposed array.
|
| Same as ``self.transpose()``.
|
| Examples
| --------
| >>> import numpy as np
| >>> a = np.array([[1, 2], [3, 4]])
| >>> a
| array([[1, 2],
| [3, 4]])
| >>> a.T
| array([[1, 3],
| [2, 4]])
|
| >>> a = np.array([1, 2, 3, 4])
| >>> a
| array([1, 2, 3, 4])
| >>> a.T
| array([1, 2, 3, 4])
|
| See Also
| --------
| transpose
|
| __array_interface__
| Array protocol: Python side.
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: C-struct side.
|
| base
| Base object if memory is from some other object.
|
| Examples
| --------
| The base of an array that owns its memory is None:
|
| >>> import numpy as np
| >>> x = np.array([1,2,3,4])
| >>> x.base is None
| True
|
| Slicing creates a view, whose memory is shared with x:
|
| >>> y = x[2:]
| >>> y.base is x
| True
|
| ctypes
| An object to simplify the interaction of the array with the ctypes
| module.
|
| This attribute creates an object that makes it easier to use arrays
| when calling shared libraries with the ctypes module. The returned
| object has, among others, data, shape, and strides attributes (see
| Notes below) which themselves return ctypes objects that can be used
| as arguments to a shared library.
|
| Parameters
| ----------
| None
|
| Returns
| -------
| c : Python object
| Possessing attributes data, shape, strides, etc.
|
| See Also
| --------
| numpy.ctypeslib
|
| Notes
| -----
| Below are the public attributes of this object which were documented
| in "Guide to NumPy" (we have omitted undocumented public attributes,
| as well as documented private attributes):
|
| .. autoattribute:: numpy._core._internal._ctypes.data
| :noindex:
|
| .. autoattribute:: numpy._core._internal._ctypes.shape
| :noindex:
|
| .. autoattribute:: numpy._core._internal._ctypes.strides
| :noindex:
|
| .. automethod:: numpy._core._internal._ctypes.data_as
| :noindex:
|
| .. automethod:: numpy._core._internal._ctypes.shape_as
| :noindex:
|
| .. automethod:: numpy._core._internal._ctypes.strides_as
| :noindex:
|
| If the ctypes module is not available, then the ctypes attribute
| of array objects still returns something useful, but ctypes objects
| are not returned and errors may be raised instead. In particular,
| the object will still have the ``as_parameter`` attribute which will
| return an integer equal to the data attribute.
|
| Examples
| --------
| >>> import numpy as np
| >>> import ctypes
| >>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)
| >>> x
| array([[0, 1],
| [2, 3]], dtype=int32)
| >>> x.ctypes.data
| 31962608 # may vary
| >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32))
| <__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary
| >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents
| c_uint(0)
| >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents
| c_ulong(4294967296)
| >>> x.ctypes.shape
| <numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary
| >>> x.ctypes.strides
| <numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary
|
| data
| Python buffer object pointing to the start of the array's data.
|
| device
|
| dtype
| Data-type of the array's elements.
|
| .. warning::
|
| Setting ``arr.dtype`` is discouraged and may be deprecated in the
| future. Setting will replace the ``dtype`` without modifying the
| memory (see also `ndarray.view` and `ndarray.astype`).
|
| Parameters
| ----------
| None
|
| Returns
| -------
| d : numpy dtype object
|
| See Also
| --------
| ndarray.astype : Cast the values contained in the array to a new data-type.
| ndarray.view : Create a view of the same data but a different data-type.
| numpy.dtype
|
| Examples
| --------
| >>> x
| array([[0, 1],
| [2, 3]])
| >>> x.dtype
| dtype('int32')
| >>> type(x.dtype)
| <type 'numpy.dtype'>
|
| flags
| Information about the memory layout of the array.
|
| Attributes
| ----------
| C_CONTIGUOUS (C)
| The data is in a single, C-style contiguous segment.
| F_CONTIGUOUS (F)
| The data is in a single, Fortran-style contiguous segment.
| OWNDATA (O)
| The array owns the memory it uses or borrows it from another object.
| WRITEABLE (W)
| The data area can be written to. Setting this to False locks
| the data, making it read-only. A view (slice, etc.) inherits WRITEABLE
| from its base array at creation time, but a view of a writeable
| array may be subsequently locked while the base array remains writeable.
| (The opposite is not true, in that a view of a locked array may not
| be made writeable. However, currently, locking a base object does not
| lock any views that already reference it, so under that circumstance it
| is possible to alter the contents of a locked array via a previously
| created writeable view onto it.) Attempting to change a non-writeable
| array raises a RuntimeError exception.
| ALIGNED (A)
| The data and all elements are aligned appropriately for the hardware.
| WRITEBACKIFCOPY (X)
| This array is a copy of some other array. The C-API function
| PyArray_ResolveWritebackIfCopy must be called before deallocating
| to the base array will be updated with the contents of this array.
| FNC
| F_CONTIGUOUS and not C_CONTIGUOUS.
| FORC
| F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
| BEHAVED (B)
| ALIGNED and WRITEABLE.
| CARRAY (CA)
| BEHAVED and C_CONTIGUOUS.
| FARRAY (FA)
| BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
|
| Notes
| -----
| The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
| or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
| names are only supported in dictionary access.
|
| Only the WRITEBACKIFCOPY, WRITEABLE, and ALIGNED flags can be
| changed by the user, via direct assignment to the attribute or dictionary
| entry, or by calling `ndarray.setflags`.
|
| The array flags cannot be set arbitrarily:
|
| - WRITEBACKIFCOPY can only be set ``False``.
| - ALIGNED can only be set ``True`` if the data is truly aligned.
| - WRITEABLE can only be set ``True`` if the array owns its own memory
| or the ultimate owner of the memory exposes a writeable buffer
| interface or is a string.
|
| Arrays can be both C-style and Fortran-style contiguous simultaneously.
| This is clear for 1-dimensional arrays, but can also be true for higher
| dimensional arrays.
|
| Even for contiguous arrays a stride for a given dimension
| ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
| or the array has no elements.
| It does *not* generally hold that ``self.strides[-1] == self.itemsize``
| for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
| Fortran-style contiguous arrays is true.
|
| flat
| A 1-D iterator over the array.
|
| This is a `numpy.flatiter` instance, which acts similarly to, but is not
| a subclass of, Python's built-in iterator object.
|
| See Also
| --------
| flatten : Return a copy of the array collapsed into one dimension.
|
| flatiter
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.arange(1, 7).reshape(2, 3)
| >>> x
| array([[1, 2, 3],
| [4, 5, 6]])
| >>> x.flat[3]
| 4
| >>> x.T
| array([[1, 4],
| [2, 5],
| [3, 6]])
| >>> x.T.flat[3]
| 5
| >>> type(x.flat)
| <class 'numpy.flatiter'>
|
| An assignment example:
|
| >>> x.flat = 3; x
| array([[3, 3, 3],
| [3, 3, 3]])
| >>> x.flat[[1,4]] = 1; x
| array([[3, 1, 3],
| [3, 1, 3]])
|
| imag
| The imaginary part of the array.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.sqrt([1+0j, 0+1j])
| >>> x.imag
| array([ 0. , 0.70710678])
| >>> x.imag.dtype
| dtype('float64')
|
| itemset
|
| itemsize
| Length of one array element in bytes.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.array([1,2,3], dtype=np.float64)
| >>> x.itemsize
| 8
| >>> x = np.array([1,2,3], dtype=np.complex128)
| >>> x.itemsize
| 16
|
| mT
| View of the matrix transposed array.
|
| The matrix transpose is the transpose of the last two dimensions, even
| if the array is of higher dimension.
|
| .. versionadded:: 2.0
|
| Raises
| ------
| ValueError
| If the array is of dimension less than 2.
|
| Examples
| --------
| >>> import numpy as np
| >>> a = np.array([[1, 2], [3, 4]])
| >>> a
| array([[1, 2],
| [3, 4]])
| >>> a.mT
| array([[1, 3],
| [2, 4]])
|
| >>> a = np.arange(8).reshape((2, 2, 2))
| >>> a
| array([[[0, 1],
| [2, 3]],
| <BLANKLINE>
| [[4, 5],
| [6, 7]]])
| >>> a.mT
| array([[[0, 2],
| [1, 3]],
| <BLANKLINE>
| [[4, 6],
| [5, 7]]])
|
| nbytes
| Total bytes consumed by the elements of the array.
|
| Notes
| -----
| Does not include memory consumed by non-element attributes of the
| array object.
|
| See Also
| --------
| sys.getsizeof
| Memory consumed by the object itself without parents in case view.
| This does include memory consumed by non-element attributes.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.zeros((3,5,2), dtype=np.complex128)
| >>> x.nbytes
| 480
| >>> np.prod(x.shape) * x.itemsize
| 480
|
| ndim
| Number of array dimensions.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.array([1, 2, 3])
| >>> x.ndim
| 1
| >>> y = np.zeros((2, 3, 4))
| >>> y.ndim
| 3
|
| newbyteorder
|
| ptp
|
| real
| The real part of the array.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.sqrt([1+0j, 0+1j])
| >>> x.real
| array([ 1. , 0.70710678])
| >>> x.real.dtype
| dtype('float64')
|
| See Also
| --------
| numpy.real : equivalent function
|
| shape
| Tuple of array dimensions.
|
| The shape property is usually used to get the current shape of an array,
| but may also be used to reshape the array in-place by assigning a tuple of
| array dimensions to it. As with `numpy.reshape`, one of the new shape
| dimensions can be -1, in which case its value is inferred from the size of
| the array and the remaining dimensions. Reshaping an array in-place will
| fail if a copy is required.
|
| .. warning::
|
| Setting ``arr.shape`` is discouraged and may be deprecated in the
| future. Using `ndarray.reshape` is the preferred approach.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.array([1, 2, 3, 4])
| >>> x.shape
| (4,)
| >>> y = np.zeros((2, 3, 4))
| >>> y.shape
| (2, 3, 4)
| >>> y.shape = (3, 8)
| >>> y
| array([[ 0., 0., 0., 0., 0., 0., 0., 0.],
| [ 0., 0., 0., 0., 0., 0., 0., 0.],
| [ 0., 0., 0., 0., 0., 0., 0., 0.]])
| >>> y.shape = (3, 6)
| Traceback (most recent call last):
| File "<stdin>", line 1, in <module>
| ValueError: total size of new array must be unchanged
| >>> np.zeros((4,2))[::2].shape = (-1,)
| Traceback (most recent call last):
| File "<stdin>", line 1, in <module>
| AttributeError: Incompatible shape for in-place modification. Use
| `.reshape()` to make a copy with the desired shape.
|
| See Also
| --------
| numpy.shape : Equivalent getter function.
| numpy.reshape : Function similar to setting ``shape``.
| ndarray.reshape : Method similar to setting ``shape``.
|
| size
| Number of elements in the array.
|
| Equal to ``np.prod(a.shape)``, i.e., the product of the array's
| dimensions.
|
| Notes
| -----
| `a.size` returns a standard arbitrary precision Python integer. This
| may not be the case with other methods of obtaining the same value
| (like the suggested ``np.prod(a.shape)``, which returns an instance
| of ``np.int_``), and may be relevant if the value is used further in
| calculations that may overflow a fixed size integer type.
|
| Examples
| --------
| >>> import numpy as np
| >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
| >>> x.size
| 30
| >>> np.prod(x.shape)
| 30
|
| strides
| Tuple of bytes to step in each dimension when traversing an array.
|
| The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
| is::
|
| offset = sum(np.array(i) * a.strides)
|
| A more detailed explanation of strides can be found in
| :ref:`arrays.ndarray`.
|
| .. warning::
|
| Setting ``arr.strides`` is discouraged and may be deprecated in the
| future. `numpy.lib.stride_tricks.as_strided` should be preferred
| to create a new view of the same data in a safer way.
|
| Notes
| -----
| Imagine an array of 32-bit integers (each 4 bytes)::
|
| x = np.array([[0, 1, 2, 3, 4],
| [5, 6, 7, 8, 9]], dtype=np.int32)
|
| This array is stored in memory as 40 bytes, one after the other
| (known as a contiguous block of memory). The strides of an array tell
| us how many bytes we have to skip in memory to move to the next position
| along a certain axis. For example, we have to skip 4 bytes (1 value) to
| move to the next column, but 20 bytes (5 values) to get to the same
| position in the next row. As such, the strides for the array `x` will be
| ``(20, 4)``.
|
| See Also
| --------
| numpy.lib.stride_tricks.as_strided
|
| Examples
| --------
| >>> import numpy as np
| >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
| >>> y
| array([[[ 0, 1, 2, 3],
| [ 4, 5, 6, 7],
| [ 8, 9, 10, 11]],
| [[12, 13, 14, 15],
| [16, 17, 18, 19],
| [20, 21, 22, 23]]])
| >>> y.strides
| (48, 16, 4)
| >>> y[1,1,1]
| 17
| >>> offset=sum(y.strides * np.array((1,1,1)))
| >>> offset/y.itemsize
| 17
|
| >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
| >>> x.strides
| (32, 4, 224, 1344)
| >>> i = np.array([3,5,2,2])
| >>> offset = sum(i * x.strides)
| >>> x[3,5,2,2]
| 813
| >>> offset / x.itemsize
| 813
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from numpy.ndarray:
|
| __hash__ = None
pyvista.raise_has_duplicates
Python Library Documentation: function raise_has_duplicates in module pyvista.core.utilities.arrays
raise_has_duplicates(arr: 'NumpyArray[Any]') -> 'None'
Raise a ValueError if an array is not unique.
Parameters
----------
arr : numpy.ndarray
Array to be checked for duplicates.
Raises
------
ValueError
If the array contains duplicate values.
pyvista.raise_not_matching
Python Library Documentation: function raise_not_matching in module pyvista.core.utilities.arrays
raise_not_matching(scalars: 'npt.NDArray[Any]', dataset: 'DataSet | Table') -> 'None'
Raise exception about inconsistencies.
Parameters
----------
scalars : numpy.ndarray
Array of scalars.
dataset : pyvista.DataSet | pyvista.Table
Dataset to check against.
Raises
------
ValueError
Raises a ValueError if the size of scalars does not the dataset.
pyvista.read
Python Library Documentation: function read in module pyvista.core.utilities.fileio
read(filename: 'PathStrSeq', force_ext: 'str | None' = None, file_format: 'str | None' = None, progress_bar: 'bool' = False, *, cls: 'type[DataObject] | None' = None, validate: 'bool | None' = None) -> 'DataObject'
Read any file type supported by ``vtk`` or ``meshio``.
Automatically determines the correct reader to use then wraps the
corresponding mesh as a pyvista object. Attempts native ``vtk``
readers first then tries to use ``meshio``. :py:mod:`Pickled<pickle>`
meshes (``'.pkl'`` or ``'.pickle'``) are also supported.
Remote URIs (``https://``, ``s3://``, etc.) are downloaded to a
temporary file automatically. Install ``fsspec`` for full protocol
support (``pip install pyvista[io]``); ``pooch`` is used as a
fallback for HTTP(S). Third-party reader plugins registered via
:func:`pyvista.register_reader` are also checked.
See :func:`pyvista.get_reader` for list of vtk formats supported.
.. include:: /api/utilities/mesh_io.rst
.. note::
See https://github.com/nschloe/meshio for formats supported by
``meshio``. Be sure to install ``meshio`` with ``pip install
meshio`` if you wish to use it.
.. versionadded:: 0.45
Support reading pickled meshes.
.. warning::
The pickle module is not secure. Only read pickled mesh files
(``'.pkl'`` or ``'.pickle'``) you trust. See :py:mod:`pickle`
for details.
See Also
--------
pyvista.DataObject.save
Save a mesh to file.
Parameters
----------
filename : str, Path, Sequence[str | Path]
The string path to the file to read. If a list of files is
given, a :class:`pyvista.MultiBlock` dataset is returned with
each file being a separate block in the dataset.
force_ext : str, optional
If specified, the reader will be chosen by an extension which
is different to its actual extension. For example, ``'.vts'``,
``'.vtu'``.
file_format : str, optional
Format of file to read with meshio.
progress_bar : bool, default: False
Optionally show a progress bar. Ignored when using ``meshio``.
cls : type, optional
Expected concrete type of the returned mesh. When given, the
result is checked with :func:`isinstance` and a
:class:`TypeError` is raised on mismatch. Static type checkers
(``mypy``, ``pyright``) use this to narrow the return type to
``cls`` directly, so callers do not need ``typing.cast`` or a
manual ``assert isinstance`` to access subclass-specific
attributes, e.g. ``pv.read('file.vtu', cls=pv.UnstructuredGrid)``.
validate : bool, optional
Forwarded to :func:`pyvista.wrap` as the ``validate`` keyword when
using a ``vtk`` reader. When ``None`` (the default), honors
:attr:`pyvista.core.config.Config.validate_on_wrap`. Pass ``False`` to
skip the cheap array-length sanity check on very large trusted
files. Has no effect for ``meshio`` or pickle code paths.
.. versionadded:: 0.48
Returns
-------
pyvista.DataSet | pyvista.MultiBlock
Wrapped PyVista dataset. When ``cls`` is given, an instance of
``cls`` is returned instead.
Examples
--------
Load an example mesh.
>>> import pyvista as pv
>>> from pyvista import examples
>>> mesh = pv.read(examples.antfile)
>>> mesh.plot(cpos='xz')
Narrow the return type to a specific class. This avoids the need for
a manual ``cast`` when working with type checkers such as ``mypy``
or ``pyright``.
>>> mesh = pv.read('mesh.vtu', cls=pv.UnstructuredGrid) # doctest:+SKIP
Load a vtk file.
>>> mesh = pv.read('my_mesh.vtk') # doctest:+SKIP
Load a meshio file.
>>> mesh = pv.read('mesh.obj') # doctest:+SKIP
Load a pickled mesh file.
>>> mesh = pv.read('mesh.pkl') # doctest:+SKIP
pyvista.read_exodus
Python Library Documentation: function read_exodus in module pyvista.core.utilities.fileio
read_exodus(filename: 'str | Path', animate_mode_shapes: 'bool' = True, apply_displacements: 'bool' = True, displacement_magnitude: 'float' = 1.0, read_point_data: 'bool' = True, read_cell_data: 'bool' = True, enabled_sidesets: 'Iterable[str | int] | None' = None) -> 'DataSet | MultiBlock'
Read an ExodusII file (``'.e'`` or ``'.exo'``).
Parameters
----------
filename : str, Path
The path to the exodus file to read.
animate_mode_shapes : bool, default: True
When ``True`` then this reader will report a continuous time
range [0,1] and animate the displacements in a periodic
sinusoid.
apply_displacements : bool, default: True
Geometric locations can include displacements. When ``True``,
the nodal positions are 'displaced' by the standard exodus
displacement vector. If displacements are turned off, the user
can explicitly add them by applying a warp filter.
displacement_magnitude : float, default: 1.0
This is a number between 0 and 1 that is used to scale the
``DisplacementMagnitude`` in a sinusoidal pattern.
read_point_data : bool, default: True
Read in data associated with points.
read_cell_data : bool, default: True
Read in data associated with cells.
enabled_sidesets : Iterable[str | int], optional
The name of the array that store the mapping from side set
cells back to the global id of the elements they bound.
Returns
-------
pyvista.DataSet
Wrapped PyVista dataset.
Examples
--------
>>> import pyvista as pv
>>> data = pv.read_exodus('mymesh.exo') # doctest:+SKIP
pyvista.read_grdecl
Python Library Documentation: function read_grdecl in module pyvista.core.utilities.fileio
read_grdecl(filename: 'str | Path', elevation: 'bool' = True, other_keywords: 'Sequence[str] | None' = None) -> 'ExplicitStructuredGrid'
Read a GRDECL file (``'.GRDECL'``).
Parameters
----------
filename : str | Path
The path to the GRDECL file to read.
elevation : bool, default: True
If True, convert depths to elevations and flip grid along Z axis.
other_keywords : sequence[str], optional
Additional keywords to read that are ignored by default.
Returns
-------
pyvista.ExplicitStructuredGrid
Output explicit structured grid.
Examples
--------
Read a ``'.GRDECL'`` file.
>>> import pyvista as pv
>>> grid = pv.read('file.GRDECL') # doctest:+SKIP
Unused keywords contained in the file are stored in :attr:`pyvista.DataObject.user_dict`:
>>> grid.user_dict # doctest:+SKIP
{"MAPUNITS": ..., "GRIDUNIT": ..., ...}
pyvista.read_meshio
Python Library Documentation: function read_meshio in module pyvista.core.utilities.fileio
read_meshio(filename: 'str | Path', file_format: 'str | None' = None) -> 'UnstructuredGrid'
Read any mesh file using meshio.
Parameters
----------
filename : str
The name of the file to read. It should include the file extension.
file_format : str, optional
The format of the file to read. If not provided, the file format will
be inferred from the file extension.
Returns
-------
UnstructuredGrid
The mesh read from the file.
Raises
------
ImportError
If the meshio package is not installed.
pyvista.read_pickle
Python Library Documentation: function read_pickle in module pyvista.core.utilities.fileio
read_pickle(filename: 'str | Path') -> 'DataObject'
Load a pickled mesh from file.
Parameters
----------
filename : str
The path of the pickled mesh to read.
Returns
-------
pyvista.DataObject
Unpickled mesh.
Examples
--------
Save a pickled mesh and read it.
>>> import pyvista as pv
>>> from pyvista import examples
>>> mesh = examples.load_ant()
>>> pv.save_pickle('ant.pkl', mesh)
>>> new_mesh = pv.read_pickle('ant.pkl')
>>> new_mesh
PolyData (...)
N Cells: 912
N Points: 486
N Strips: 0
X Bounds: -1.601e+01, 1.601e+01
Y Bounds: -9.385e+00, 9.385e+00
Z Bounds: -1.678e+01, 1.678e+01
N Arrays: 0
Unlike other file formats, custom attributes are saved with pickled meshes.
>>> pv.set_new_attribute(mesh, 'custom_attribute', 42)
>>> pv.save_pickle('ant.pkl', mesh)
>>> new_mesh = pv.read_pickle('ant.pkl')
>>> new_mesh.custom_attribute
42
pyvista.read_texture
Python Library Documentation: function read_texture in module pyvista.core.utilities.fileio
read_texture(filename: 'str | Path', progress_bar: 'bool' = False) -> 'Texture'
Load a texture from an image file.
Will attempt to read any file type supported by ``vtk``, however
if it fails, it will attempt to use ``imageio`` to read the file.
Parameters
----------
filename : str
The path of the texture file to read.
progress_bar : bool, default: False
Optionally show a progress bar.
Returns
-------
pyvista.Texture
PyVista texture object.
Examples
--------
Read in an example jpg map file as a texture.
>>> from pathlib import Path
>>> import pyvista as pv
>>> from pyvista import examples
>>> Path(examples.mapfile).name
'2k_earth_daymap.jpg'
>>> texture = pv.read_texture(examples.mapfile)
>>> type(texture)
<class 'pyvista.plotting.texture.Texture'>
pyvista.reader
Error rendering doc: 'NoneType' object is not iterable
pyvista.reader_registry
Python Library Documentation: module pyvista.core.utilities.reader_registry in pyvista.core.utilities
NAME
pyvista.core.utilities.reader_registry - Pluggable reader registry for custom file formats.
CLASSES
builtins.Exception(builtins.BaseException)
LocalFileRequiredError
builtins.tuple(builtins.object)
ReaderRegistration
typing.Protocol(typing.Generic)
ReaderHandler
class LocalFileRequiredError(builtins.Exception)
| Raise from a registered reader to signal it needs a local file path.
|
| When :func:`pyvista.read` passes a remote URI to a custom reader and
| the reader raises this exception, PyVista will download the file to a
| temporary local path and retry the reader automatically.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> from pyvista.core.utilities.reader_registry import LocalFileRequiredError
| >>> @pv.register_reader('.myformat') # doctest: +SKIP
| ... def my_reader(path, **kwargs):
| ... if '://' in path:
| ... raise LocalFileRequiredError
| ... ...
|
| Method resolution order:
| LocalFileRequiredError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class ReaderHandler(typing.Protocol)
| ReaderHandler(*args, **kwargs)
|
| Callable that reads *path* and returns a :class:`pyvista.DataSet`.
|
| Method resolution order:
| ReaderHandler
| typing.Protocol
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __call__(self, path: 'str', /, **kwargs: 'Any') -> 'DataSet'
| Read *path* and return the resulting dataset.
|
| __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __subclasshook__ = _proto_hook(other) from typing
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __protocol_attrs__ = {'__call__'}
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Protocol:
|
| __init_subclass__(*args, **kwargs)
| Function to initialize subclasses.
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Generic:
|
| __class_getitem__(...)
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
class ReaderRegistration(builtins.tuple)
| ReaderRegistration(extension: ForwardRef('str'), handler: ForwardRef('ReaderHandler'), source: ForwardRef('str'))
|
| Describe one registered custom reader.
|
| Returned by :func:`~pyvista.registered_readers`.
|
| .. versionadded:: 0.48.0
|
| Attributes
| ----------
| extension : str
| File extension the reader is registered against, including the
| leading dot (e.g. ``'.myformat'``).
| handler : callable
| The reader callable.
| source : str
| Human-readable origin in the form ``'module.qualname'`` for
| explicit registrations or the entry-point ``value`` for
| plugin-discovered registrations.
|
| Method resolution order:
| ReaderRegistration
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.ReaderRegistration
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.ReaderRegistration
| Return a nicely formatted representation string
|
| _asdict(self) from collections.ReaderRegistration
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.ReaderRegistration
| Return a new ReaderRegistration object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.ReaderRegistration
| Make a new ReaderRegistration object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, extension: ForwardRef('str'), handler: ForwardRef('ReaderHandler'), source: ForwardRef('str')) from namedtuple_ReaderRegistration.ReaderRegistration
| Create new instance of ReaderRegistration(extension, handler, source)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| extension
| Alias for field number 0
|
| handler
| Alias for field number 1
|
| source
| Alias for field number 2
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'extension': ForwardRef('str'), 'handler': ForwardR...
|
| __match_args__ = ('extension', 'handler', 'source')
|
| __orig_bases__ = (<function NamedTuple>,)
|
| _field_defaults = {}
|
| _fields = ('extension', 'handler', 'source')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
FUNCTIONS
has_scheme(value: 'str') -> 'bool'
Return ``True`` if *value* starts with a URI scheme (e.g. ``https://``).
Parameters
----------
value : str
The string to check.
Returns
-------
bool
``True`` if *value* contains a ``://`` scheme prefix before
the first ``/``.
register_reader(key: 'str', handler: 'ReaderHandler | None' = None, *, override: 'bool' = False) -> 'Callable[[ReaderHandler], ReaderHandler] | None'
Register a custom reader for a file extension.
Can be used as a plain call or as a decorator.
.. versionadded:: 0.48.0
Parameters
----------
key : str
A file extension (e.g. ``'.myformat'``).
handler : callable, optional
A callable with signature ``handler(path: str, **kwargs)`` that
returns a :class:`pyvista.DataSet`. When omitted the function
acts as a decorator and returns the decorated callable unchanged.
override : bool, default: False
If ``True``, allow overriding a built-in VTK reader for this
extension and silence the warning that would otherwise fire when
replacing an existing custom registration.
Returns
-------
callable or None
When used as a decorator (``handler`` omitted), returns the
decorated function. Otherwise returns ``None``.
Raises
------
ValueError
If ``key`` collides with a built-in VTK reader and *override*
is ``False``.
Warns
-----
UserWarning
If ``key`` already refers to a registered custom reader. The new
registration replaces the old one (last wins); pass
``override=True`` to silence the warning.
See Also
--------
pyvista.register_writer
Sibling API for registering custom writers.
pyvista.registered_readers
Introspect every registered reader.
Examples
--------
Register a reader for a custom file extension.
>>> import pyvista as pv
>>> def my_reader(path, **kwargs): ...
>>> pv.register_reader('.myformat', my_reader) # doctest: +SKIP
Use as a decorator.
>>> @pv.register_reader('.myformat') # doctest: +SKIP
... def my_reader(path, **kwargs): ...
registered_readers() -> 'tuple[ReaderRegistration, ...]'
Return every custom reader currently registered.
Forces discovery of any pending entry-point plugins so the returned
list reflects every reader visible to PyVista. A plugin that fails to
import emits a ``UserWarning`` and is skipped; the rest still appear
in the result.
.. versionadded:: 0.48.0
Returns
-------
tuple[ReaderRegistration, ...]
One record per registered extension. Each record exposes
``extension``, ``handler``, and ``source``.
Examples
--------
>>> import pyvista as pv
>>> def my_reader(path, **kwargs): ...
>>> pv.register_reader('.demo_reader', my_reader)
>>> [
... r.extension
... for r in pv.registered_readers()
... if r.extension == '.demo_reader'
... ]
['.demo_reader']
DATA
CLASS_READERS = {'.bmp': <class 'pyvista.core.utilities.reader.BMPRead...
TYPE_CHECKING = False
__annotations__ = {'_custom_ext_reader_sources': 'dict[str, str]', '_c...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\reader_registry.py
pyvista.register_dataset_accessor
Python Library Documentation: function register_dataset_accessor in module pyvista.core.utilities.accessor_registry
register_dataset_accessor(name: 'str', target_cls: 'type', *, override: 'bool' = False) -> 'Callable[[type], type]'
Register a custom namespaced accessor on a PyVista dataset class.
Mirrors the accessor pattern used by
`pandas <https://pandas.pydata.org/docs/development/extending.html#registering-custom-accessors>`_
and `xarray <https://docs.xarray.dev/en/stable/internals/extending-xarray.html>`_.
Once registered, the accessor becomes available as
``dataset.<name>.<method>(...)`` on every instance of ``target_cls``
and its subclasses. The accessor class is instantiated lazily on
first access and cached on the dataset instance, so subsequent
accesses return the same accessor object.
.. versionadded:: 0.48.0
Parameters
----------
name : str
The namespace the accessor will be attached under. Must be a
valid Python identifier that does not start with an underscore.
target_cls : type
The PyVista dataset class (or base class) to attach the accessor
to. Registering against :class:`~pyvista.DataSet` exposes the
accessor on every subclass (``PolyData``, ``UnstructuredGrid``,
``ImageData``, and so on). Registering against
:class:`~pyvista.DataObject` additionally covers
:class:`~pyvista.MultiBlock`.
override : bool, default: False
If ``True``, allow registering a name that shadows an existing
built-in attribute on ``target_cls`` (a filter method, property,
or any other non-accessor attribute). The prior attribute is
restored on :func:`~pyvista.unregister_dataset_accessor`.
Returns
-------
callable
Decorator that registers the accessor class passed to it and
returns that class unchanged.
Raises
------
ValueError
If ``name`` is empty, not a valid identifier, starts with ``_``,
or shadows a built-in attribute on ``target_cls`` without
``override=True``.
TypeError
If ``target_cls`` is not a class, or ``name`` is not a string.
Warns
-----
UserWarning
If ``name`` already refers to a registered accessor on
``target_cls`` or any ancestor. Emitting a warning rather than
raising matches pandas' behavior and avoids hard-failing when
two plugins collide.
See Also
--------
pyvista.unregister_dataset_accessor
pyvista.registered_accessors
pyvista.DataSetAccessor
Examples
--------
Register a minimal accessor on :class:`~pyvista.PolyData`.
>>> import pyvista as pv
>>> @pv.register_dataset_accessor('demo', pv.PolyData)
... class DemoAccessor:
... def __init__(self, mesh):
... self._mesh = mesh
...
... def n_points_doubled(self):
... return self._mesh.n_points * 2
>>> sphere = pv.Sphere()
>>> sphere.demo.n_points_doubled() == sphere.n_points * 2
True
The accessor is cached per instance. Repeated access returns the
same object.
>>> sphere.demo is sphere.demo
True
Clean up so the namespace is not visible to later doctest examples.
>>> pv.unregister_dataset_accessor('demo', pv.PolyData)
pyvista.register_jupyter_backend
Python Library Documentation: function register_jupyter_backend in module pyvista.jupyter
register_jupyter_backend(name: 'str', handler: 'Callable[..., object]', *, override: 'bool' = False) -> 'None'
Register a custom Jupyter backend handler.
.. versionadded:: 0.48.0
Parameters
----------
name : str
Name of the backend (e.g. ``'custom'``). Must not collide with
a built-in backend name unless ``override=True`` is passed.
handler : callable
A callable with signature ``handler(plotter, **kwargs)`` that
returns an IPython-displayable object.
override : bool, default: False
If ``True``, allow registering a name that collides with a
built-in backend. Also silences the warning emitted when
replacing an existing custom registration.
Raises
------
ValueError
If ``name`` collides with a built-in backend and ``override``
is ``False``.
Warns
-----
UserWarning
If ``name`` already refers to a registered custom backend. The
new registration replaces the old one (last wins); pass
``override=True`` to silence the warning.
Examples
--------
>>> import pyvista as pv
>>> def my_handler(plotter, **kwargs): ...
>>> pv.register_jupyter_backend('my_backend', my_handler) # doctest: +SKIP
pyvista.register_reader
Python Library Documentation: function register_reader in module pyvista.core.utilities.reader_registry
register_reader(key: 'str', handler: 'ReaderHandler | None' = None, *, override: 'bool' = False) -> 'Callable[[ReaderHandler], ReaderHandler] | None'
Register a custom reader for a file extension.
Can be used as a plain call or as a decorator.
.. versionadded:: 0.48.0
Parameters
----------
key : str
A file extension (e.g. ``'.myformat'``).
handler : callable, optional
A callable with signature ``handler(path: str, **kwargs)`` that
returns a :class:`pyvista.DataSet`. When omitted the function
acts as a decorator and returns the decorated callable unchanged.
override : bool, default: False
If ``True``, allow overriding a built-in VTK reader for this
extension and silence the warning that would otherwise fire when
replacing an existing custom registration.
Returns
-------
callable or None
When used as a decorator (``handler`` omitted), returns the
decorated function. Otherwise returns ``None``.
Raises
------
ValueError
If ``key`` collides with a built-in VTK reader and *override*
is ``False``.
Warns
-----
UserWarning
If ``key`` already refers to a registered custom reader. The new
registration replaces the old one (last wins); pass
``override=True`` to silence the warning.
See Also
--------
pyvista.register_writer
Sibling API for registering custom writers.
pyvista.registered_readers
Introspect every registered reader.
Examples
--------
Register a reader for a custom file extension.
>>> import pyvista as pv
>>> def my_reader(path, **kwargs): ...
>>> pv.register_reader('.myformat', my_reader) # doctest: +SKIP
Use as a decorator.
>>> @pv.register_reader('.myformat') # doctest: +SKIP
... def my_reader(path, **kwargs): ...
pyvista.register_writer
Python Library Documentation: function register_writer in module pyvista.core.utilities.writer_registry
register_writer(key: 'str', handler: 'WriterHandler | None' = None, *, override: 'bool' = False) -> 'Callable[[WriterHandler], WriterHandler] | None'
Register a custom writer for a file extension.
Can be used as a plain call or as a decorator.
.. versionadded:: 0.48.0
Parameters
----------
key : str
A file extension (e.g. ``'.myformat'``).
handler : callable, optional
A callable with signature ``handler(dataset, path, **kwargs)`` that
writes *dataset* to *path*. Any extra keyword arguments passed to
:meth:`pyvista.DataObject.save` are forwarded to the handler as
``**kwargs`` — use them to expose format-specific options such as
compression level, thread count, or chunking. Handlers that do
not need per-call options can omit ``**kwargs``; a call to
:meth:`~pyvista.DataObject.save` that passes extras to such a
handler will raise :class:`TypeError` from Python itself. When
``handler`` is omitted the function acts as a decorator and
returns the decorated callable unchanged.
override : bool, default: False
If ``True``, allow overriding a built-in PyVista writer for this
extension and silence the warning that would otherwise fire when
replacing an existing custom registration.
Returns
-------
callable or None
When used as a decorator (``handler`` omitted), returns the
decorated function. Otherwise returns ``None``.
Raises
------
ValueError
If ``key`` collides with a built-in PyVista writer and *override*
is ``False``.
Warns
-----
UserWarning
If ``key`` already refers to a registered custom writer. The new
registration replaces the old one (last wins); pass
``override=True`` to silence the warning.
See Also
--------
pyvista.register_reader
Sibling API for registering custom readers.
pyvista.registered_writers
Introspect every registered writer.
Notes
-----
When :meth:`pyvista.DataObject.save` is called, registered custom
writers are dispatched *before* built-in VTK writers — mirroring
the dispatch order of :func:`pyvista.read`. Passing
``override=True`` is therefore the only way to replace a built-in
writer at save time.
Any keyword arguments passed to :meth:`~pyvista.DataObject.save`
beyond its documented parameters are forwarded verbatim to the
registered handler. When no custom writer is registered for the
target extension, extra keyword arguments raise :class:`TypeError`
from :meth:`~pyvista.DataObject.save` — PyVista never silently
drops writer options.
Examples
--------
Register a writer for a custom file extension with a
format-specific option.
>>> import pyvista as pv
>>> def my_writer(dataset, path, *, level=3): ...
>>> pv.register_writer('.myformat', my_writer) # doctest:+SKIP
>>> pv.Sphere().save('sphere.myformat', level=9) # doctest:+SKIP
Use as a decorator.
>>> @pv.register_writer('.myformat') # doctest:+SKIP
... def my_writer(dataset, path, **kwargs): ...
pyvista.registered_accessors
Python Library Documentation: function registered_accessors in module pyvista.core.utilities.accessor_registry
registered_accessors() -> 'tuple[AccessorRegistration, ...]'
Return every accessor currently registered.
Forces discovery of any pending entry-point plugins so the returned
list reflects every plugin visible to PyVista, not just the ones
that have been touched already via attribute access. A plugin that
fails to import emits a ``UserWarning`` and is skipped; the rest
still appear in the result.
.. versionadded:: 0.48.0
Returns
-------
tuple[AccessorRegistration, ...]
Ordered by registration time. Each record exposes ``name``,
``target``, ``accessor``, and ``source``.
Examples
--------
>>> import pyvista as pv
>>> @pv.register_dataset_accessor('demo_listed', pv.PolyData)
... class DemoListedAccessor:
... def __init__(self, mesh):
... self._mesh = mesh
>>> [r.name for r in pv.registered_accessors() if r.name == 'demo_listed']
['demo_listed']
>>> pv.unregister_dataset_accessor('demo_listed', pv.PolyData)
pyvista.registered_jupyter_backends
Python Library Documentation: function registered_jupyter_backends in module pyvista.jupyter
registered_jupyter_backends() -> 'tuple[JupyterBackendRegistration, ...]'
Return every custom Jupyter backend currently registered.
Forces discovery of any pending entry-point plugins so the returned
list reflects every backend visible to PyVista. A plugin that fails
to import emits a ``UserWarning`` and is skipped; the rest still
appear in the result.
.. versionadded:: 0.48.0
Returns
-------
tuple[JupyterBackendRegistration, ...]
One record per registered backend. Each record exposes
``name``, ``handler``, and ``source``. Built-in backends are
not included; only custom registrations.
pyvista.registered_readers
Python Library Documentation: function registered_readers in module pyvista.core.utilities.reader_registry
registered_readers() -> 'tuple[ReaderRegistration, ...]'
Return every custom reader currently registered.
Forces discovery of any pending entry-point plugins so the returned
list reflects every reader visible to PyVista. A plugin that fails to
import emits a ``UserWarning`` and is skipped; the rest still appear
in the result.
.. versionadded:: 0.48.0
Returns
-------
tuple[ReaderRegistration, ...]
One record per registered extension. Each record exposes
``extension``, ``handler``, and ``source``.
Examples
--------
>>> import pyvista as pv
>>> def my_reader(path, **kwargs): ...
>>> pv.register_reader('.demo_reader', my_reader)
>>> [
... r.extension
... for r in pv.registered_readers()
... if r.extension == '.demo_reader'
... ]
['.demo_reader']
pyvista.registered_writers
Python Library Documentation: function registered_writers in module pyvista.core.utilities.writer_registry
registered_writers() -> 'tuple[WriterRegistration, ...]'
Return every custom writer currently registered.
Forces discovery of any pending entry-point plugins so the returned
list reflects every writer visible to PyVista. A plugin that fails to
import emits a ``UserWarning`` and is skipped; the rest still appear
in the result.
.. versionadded:: 0.48.0
Returns
-------
tuple[WriterRegistration, ...]
One record per registered extension. Each record exposes
``extension``, ``handler``, and ``source``.
Examples
--------
>>> import pyvista as pv
>>> def my_writer(dataset, path, **kwargs): ...
>>> pv.register_writer('.demo_writer', my_writer)
>>> [
... r.extension
... for r in pv.registered_writers()
... if r.extension == '.demo_writer'
... ]
['.demo_writer']
pyvista.report
Python Library Documentation: module pyvista.report in pyvista
NAME
pyvista.report - Module managing errors.
CLASSES
builtins.object
GPUInfo
class GPUInfo(builtins.object)
| A class to hold GPU details.
|
| Methods defined here:
|
| __init__(self)
| Instantiate a container for the GPU information.
|
| __repr__(self)
| Representation method.
|
| __str__(self)
| Return a human-readable string representation.
|
| get_info(self)
| All GPU information as tuple pairs.
|
| Returns
| -------
| tuple
| Tuples of ``(key, info)``.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| renderer
| GPU renderer name.
|
| vendor
| GPU renderer vendor.
|
| version
| GPU renderer version.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
Report(additional: 'list[str | ModuleType] | None' = None, ncol: 'int' = 3, text_width: 'int' = 80, sort: 'bool' = False, gpu: 'bool' = True, downloads: 'bool' = False)
Generate a PyVista software environment report.
.. versionadded:: 0.47
The report can now be generated using the shell command:
.. code-block:: shell
pyvista report --sort ...
Run ``pyvista report --help`` for more details on available parameters.
Parameters
----------
additional : sequence[types.ModuleType], sequence[str]
List of packages or package names to add to output information.
ncol : int, default: 3
Number of package-columns in html table; only has effect if
``mode='HTML'`` or ``mode='html'``.
text_width : int, default: 80
The text width for non-HTML display modes.
sort : bool, default: False
Alphabetically sort the packages.
gpu : bool, default: True
Gather information about the GPU. Defaults to ``True`` but if
experiencing rendering issues, pass ``False`` to safely generate a
report.
downloads : bool, default: False
Gather information about downloads. If ``True``, includes:
- The local user data path (where downloads are saved)
- The VTK Data source (where files are downloaded from)
- Whether local file caching is enabled for the VTK Data source
.. versionadded:: 0.47
Examples
--------
>>> import pyvista as pv
>>> pv.Report() # doctest:+SKIP
Date: Fri Oct 28 15:54:11 2022 MDT
<BLANKLINE>
OS : Linux
CPU(s) : 6
Machine : x86_64
Architecture : 64bit
RAM : 62.6 GiB
Environment : IPython
File system : ext4
GPU Vendor : NVIDIA Corporation
GPU Renderer : Quadro P2000/PCIe/SSE2
GPU Version : 4.5.0 NVIDIA 470.141.03
<BLANKLINE>
Python 3.8.10 (default, Jun 22 2022, 20:18:18) [GCC 9.4.0]
<BLANKLINE>
pyvista : 0.37.dev0
vtk : 9.1.0
numpy : 1.23.3
imageio : 2.22.0
scooby : 0.7.1.dev1+gf097dad
pooch : v1.6.0
matplotlib : 3.6.0
IPython : 7.31.0
colorcet : 3.0.1
cmocean : 2.0
scipy : 1.9.1
tqdm : 4.64.1
meshio : 5.3.4
jupyterlab : 3.4.7
check_math_text_support() -> 'bool'
Check if MathText and LaTeX symbols are supported.
Returns
-------
bool
``True`` if both MathText and LaTeX symbols are supported, ``False``
otherwise.
check_matplotlib_vtk_compatibility() -> 'bool'
Check if VTK and Matplotlib versions are compatible for MathText rendering.
This function is primarily geared towards checking if MathText rendering is
supported with the given versions of VTK and Matplotlib. It follows the
version constraints:
* VTK <= 9.2.2 requires Matplotlib < 3.6
* VTK > 9.2.2 requires Matplotlib >= 3.6
Other version combinations of VTK and Matplotlib will work without
errors, but some features (like MathText/LaTeX rendering) may
silently fail.
Returns
-------
bool
True if the versions of VTK and Matplotlib are compatible for MathText
rendering, False otherwise.
Raises
------
RuntimeError
If the versions of VTK and Matplotlib cannot be checked.
get_gpu_info()
Get all information about the GPU.
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\report.py
pyvista.row_array
Python Library Documentation: function row_array in module pyvista.core.utilities.arrays
row_array(obj: '_vtk.vtkTable', name: 'str') -> 'pyvista_ndarray | None'
Return row array of a vtk object.
Parameters
----------
obj : :vtk:`vtkTable`
PyVista or VTK table.
name : str
Name of the array.
Returns
-------
numpy.ndarray
Wrapped array.
pyvista.sample_function
Python Library Documentation: function sample_function in module pyvista.core.utilities.features
sample_function(function: '_vtk.vtkImplicitFunction', bounds: 'Sequence[float]' = (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0), dim: 'Sequence[int]' = (50, 50, 50), compute_normals: 'bool' = False, output_type: 'np.dtype' = <class 'numpy.float64'>, capping: 'bool' = False, cap_value: 'float' = 1.7976931348623157e+308, scalar_arr_name: 'str' = 'scalars', normal_arr_name: 'str' = 'normals', progress_bar: 'bool' = False)
Sample an implicit function over a structured point set.
Uses :vtk:`vtkSampleFunction`
This method evaluates an implicit function and normals at each
point in a :vtk:`vtkStructuredPoints`. The user can specify the
sample dimensions and location in space to perform the sampling.
To create closed surfaces (in conjunction with the
:vtk:`vtkContourFilter`), capping can be turned on to set a particular
value on the boundaries of the sample space.
Parameters
----------
function : :vtk:`vtkImplicitFunction`
Implicit function to evaluate. For example, the function
generated from :func:`perlin_noise() <pyvista.core.utilities.features.perlin_noise>`.
bounds : sequence[float], default: (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0)
Specify the bounds in the format of:
- ``(x_min, x_max, y_min, y_max, z_min, z_max)``.
dim : sequence[float], default: (50, 50, 50)
Dimensions of the data on which to sample in the format of
``(xdim, ydim, zdim)``.
compute_normals : bool, default: False
Enable or disable the computation of normals.
output_type : numpy.dtype, default: numpy.double
Set the output scalar type. One of the following:
- ``np.float64``
- ``np.float32``
- ``np.int64``
- ``np.uint64``
- ``np.int32``
- ``np.uint32``
- ``np.int16``
- ``np.uint16``
- ``np.int8``
- ``np.uint8``
capping : bool, default: False
Enable or disable capping. If capping is enabled, then the outer
boundaries of the structured point set are set to cap value. This can
be used to ensure surfaces are closed.
cap_value : float, default: sys.float_info.max
Capping value used with the ``capping`` parameter.
scalar_arr_name : str, default: "scalars"
Set the scalar array name for this data set.
normal_arr_name : str, default: "normals"
Set the normal array name for this data set.
progress_bar : bool, default: False
Display a progress bar to indicate progress.
Returns
-------
pyvista.ImageData
Uniform grid with sampled data.
Examples
--------
Sample Perlin noise over a structured grid in 3D.
>>> import pyvista as pv
>>> noise = pv.perlin_noise(0.1, (1, 1, 1), (0, 0, 0))
>>> grid = pv.sample_function(
... noise, bounds=[0, 3.0, -0, 1.0, 0, 1.0], dim=(60, 20, 20)
... )
>>> grid.plot(cmap='gist_earth_r', show_scalar_bar=False, show_edges=True)
Sample Perlin noise in 2D and plot it.
>>> noise = pv.perlin_noise(0.1, (5, 5, 5), (0, 0, 0))
>>> surf = pv.sample_function(noise, dim=(200, 200, 1))
>>> surf.plot()
See :ref:`perlin_noise_2d_example` and :ref:`perlin_noise_3d_example`
for a full example using this function.
pyvista.save_meshio
Python Library Documentation: function save_meshio in module pyvista.core.utilities.fileio
save_meshio(filename: 'str | Path', mesh: 'DataSet', file_format: 'str | None' = None, **kwargs) -> 'None'
Save mesh to file using meshio.
Parameters
----------
filename : str
Filename to save the mesh to.
mesh : pyvista.DataSet
Any PyVista mesh/spatial data type.
file_format : str, optional
File type for meshio to save. For example ``'.bdf'``. This
is normally inferred from the extension but this can be
overridden.
**kwargs : dict, optional
Additional keyword arguments. See
``meshio.Mesh.write`` for more details.
Examples
--------
Save a pyvista sphere to a Abaqus data file.
>>> import pyvista as pv
>>> sphere = pv.Sphere()
>>> pv.save_meshio('mymesh.inp', sphere) # doctest:+SKIP
pyvista.save_pickle
Python Library Documentation: function save_pickle in module pyvista.core.utilities.fileio
save_pickle(filename: 'str | Path', mesh: 'DataObject') -> 'None'
Pickle a mesh and save it to file.
Parameters
----------
filename : str
The path of the pickled mesh to save, including the extension ``'.pkl'``
or ``'.pickle'``.
mesh : pyvista.DataObject
Any PyVista mesh.
Examples
--------
Save a pickled mesh and read it.
>>> import pyvista as pv
>>> from pyvista import examples
>>> mesh = examples.load_ant()
>>> pv.save_pickle('ant.pkl', mesh)
>>> new_mesh = pv.read_pickle('ant.pkl')
>>> new_mesh
PolyData (...)
N Cells: 912
N Points: 486
N Strips: 0
X Bounds: -1.601e+01, 1.601e+01
Y Bounds: -9.385e+00, 9.385e+00
Z Bounds: -1.678e+01, 1.678e+01
N Arrays: 0
Unlike other file formats, custom attributes are saved with pickled meshes.
>>> pv.set_new_attribute(mesh, 'custom_attribute', 42)
>>> pv.save_pickle('ant.pkl', mesh)
>>> new_mesh = pv.read_pickle('ant.pkl')
>>> new_mesh.custom_attribute
42
pyvista.send_errors_to_logging
Python Library Documentation: function send_errors_to_logging in module pyvista.core.utilities.observers
send_errors_to_logging()
Send all VTK error/warning messages to Python's logging module.
pyvista.set_default_active_scalars
Python Library Documentation: function set_default_active_scalars in module pyvista.core.utilities.arrays
set_default_active_scalars(mesh: 'DataSet') -> '_ActiveArrayExistsInfoTuple'
Set a default scalars array on mesh, if not already set.
If an active scalars already exists, no changes are made.
If an active scalars does not exist, it checks for point or cell
arrays. If only one exists, then it is set as the active scalars.
Otherwise, an error is raised.
.. versionchanged:: 0.45
The field and name of the active array is now returned.
Previously, ``None`` was returned.
Parameters
----------
mesh : pyvista.DataSet
Dataset to set default active scalars.
Raises
------
pyvista.core.errors.MissingDataError
If no arrays exist.
pyvista.core.errors.AmbiguousDataError
If more than one array exists.
Returns
-------
tuple[FieldAssociation, str]
The field and name of the active array.
pyvista.set_default_active_vectors
Python Library Documentation: function set_default_active_vectors in module pyvista.core.utilities.arrays
set_default_active_vectors(mesh: 'DataSet') -> '_ActiveArrayExistsInfoTuple'
Set a default vectors array on mesh, if not already set.
If an active vector already exists, no changes are made.
If an active vectors does not exist, it checks for possibly cell
or point arrays with shape ``(n, 3)``. If only one exists, then
it is set as the active vectors. Otherwise, an error is raised.
.. versionchanged:: 0.45
The field and name of the active array is now returned.
Previously, ``None`` was returned.
Parameters
----------
mesh : pyvista.DataSet
Dataset to set default active vectors.
Raises
------
pyvista.core.errors.MissingDataError
If no vector-like arrays exist.
pyvista.core.errors.AmbiguousDataError
If more than one vector-like arrays exist.
Returns
-------
tuple[FieldAssociation, str]
The field and name of the active array.
pyvista.set_error_output_file
Python Library Documentation: function set_error_output_file in module pyvista.core.utilities.observers
set_error_output_file(filename)
Set a file to write out the VTK errors.
Parameters
----------
filename : str, Path
Path to the file to write VTK errors to.
Returns
-------
:vtk:`vtkFileOutputWindow`
VTK file output window.
:vtk:`vtkOutputWindow`
VTK output window.
pyvista.set_jupyter_backend
Python Library Documentation: function set_jupyter_backend in module pyvista.jupyter
set_jupyter_backend(backend: 'JupyterBackendOptions | str', name=None, **kwargs)
Set the plotting backend for a jupyter notebook.
Parameters
----------
backend : str
Jupyter backend to use when plotting. Must be one of the following:
* ``'static'`` : Display a single static image within the
Jupyterlab environment. Still requires that a virtual
framebuffer be set up when displaying on a headless server,
but does not require any additional modules to be installed.
* ``'client'`` : Export/serialize the scene graph to be rendered
with VTK.js client-side through ``trame``. Requires ``trame``
and ``jupyter-server-proxy`` to be installed.
* ``'server'``: Render remotely and stream the resulting VTK
images back to the client using ``trame``. This replaces the
``'ipyvtklink'`` backend with better performance.
Supports the most VTK features, but suffers from minor lag due
to remote rendering. Requires that a virtual framebuffer be set
up when displaying on a headless server. Must have at least ``trame``
and ``jupyter-server-proxy`` installed for cloud/remote Jupyter
instances. This mode is also aliased by ``'trame'``.
* ``'trame'``: The full Trame-based backend that combines both
``'server'`` and ``'client'`` into one backend. This requires a
virtual frame buffer.
* ``'html'`` : Export/serialize the scene graph to be rendered
with the Trame client backend but in a static HTML file.
* ``'none'`` : Do not display any plots within jupyterlab,
instead display using dedicated VTK render windows. This
will generate nothing on headless servers even with a
virtual framebuffer.
Custom backends registered via :func:`~pyvista.register_jupyter_backend`
are also accepted. Pass ``None`` to reset to auto-detection at display
time.
name : str, optional
The unique name identifier for the server.
**kwargs : dict, optional
Any additional keyword arguments to pass to the server launch.
Examples
--------
Enable the trame Trame backend.
>>> pv.set_jupyter_backend('trame') # doctest:+SKIP
Just show static images.
>>> pv.set_jupyter_backend('static') # doctest:+SKIP
Disable all plotting within JupyterLab and display using a
standard desktop VTK render window.
>>> pv.set_jupyter_backend('none') # doctest:+SKIP
Reset to auto-detect the best available backend.
>>> pv.set_jupyter_backend(None) # doctest:+SKIP
pyvista.set_new_attribute
Python Library Documentation: function set_new_attribute in module pyvista.core.utilities.misc
set_new_attribute(obj: 'object', name: 'str', value: 'Any') -> 'None'
Set a new attribute for this object.
Python allows arbitrarily setting new attributes on objects at any time,
but PyVista's classes do not allow this. If an attribute is not part of
PyVista's API, an ``AttributeError`` is normally raised when attempting
to set it.
Use :func:`set_new_attribute` to override this and set a new attribute anyway.
See Also
--------
pyvista.allow_new_attributes
Context manager for controlling if setting new attributes is allowed.
Examples
--------
Set a new custom attribute on a mesh.
>>> import pyvista as pv
>>> mesh = pv.PolyData()
>>> pv.set_new_attribute(mesh, 'foo', 42)
>>> mesh.foo
42
This is equivalent to using :data:`allow_new_attributes` with ``True``.
>>> with pv.allow_new_attributes(True):
... mesh.foo = 42
.. versionadded:: 0.46
pyvista.set_pickle_format
Python Library Documentation: function set_pickle_format in module pyvista.core.utilities.fileio
set_pickle_format(format: "Literal['vtk', 'xml', 'legacy']") -> 'None'
Set the format used to serialize :class:`pyvista.DataObject` when pickled.
Parameters
----------
format : str
The format for serialization. Acceptable values are:
- ``'vtk'`` (default) : objects are serialized using VTK's official
marshalling methods.
- ``'xml'``: objects are serialized as an XML-formatted string.
- ``'legacy'`` objects are serialized to bytes in VTK's binary format.
.. note::
The ``'vtk'`` format requires VTK 9.3 or greater.
.. warning::
``'xml'`` and ``'legacy'`` are not recommended. These formats are not
officially supported by VTK and have limitations. For example, these
formats cannot be used to pickle :class:`pyvista.MultiBlock`.
Raises
------
ValueError
If the provided format is not supported.
pyvista.spherical_to_cartesian
Python Library Documentation: function spherical_to_cartesian in module pyvista.core.utilities.features
spherical_to_cartesian(r, phi, theta)
Convert Spherical coordinates to 3D Cartesian coordinates.
Parameters
----------
r : numpy.ndarray
Radial distance.
phi : numpy.ndarray
Angle (radians) with respect to the polar axis. Also known
as polar angle.
theta : numpy.ndarray
Angle (radians) of rotation from the initial meridian plane.
Also known as azimuthal angle.
Returns
-------
output : numpy.ndarray, numpy.ndarray, numpy.ndarray
Cartesian coordinates.
pyvista.state_manager
Python Library Documentation: module pyvista.core.utilities.state_manager in pyvista.core.utilities
NAME
pyvista.core.utilities.state_manager - Context manager for controlling global state variables.
DATA
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
T = ~T
TYPE_CHECKING = False
allow_new_attributes = <pyvista.core.utilities.state_manager._AllowNew...
vtk_snake_case = <pyvista.core.utilities.state_manager._vtkSnakeCase o...
vtk_verbosity = <pyvista.core.utilities.state_manager._VTKVerbosity ob...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\state_manager.py
pyvista.surface_from_para
Python Library Documentation: function surface_from_para in module pyvista.core.utilities.parametric_objects
surface_from_para(parametric_function: '_vtk.vtkParametricFunction', u_res: 'int' = 100, v_res: 'int' = 100, w_res: 'int' = 100, clean: 'bool' = False, texture_coordinates: 'bool' = False) -> 'PolyData'
Construct a mesh from a parametric function.
Parameters
----------
parametric_function : :vtk:`vtkParametricFunction`
Parametric function to generate mesh from.
u_res : int, default: 100
Resolution in the u direction.
v_res : int, default: 100
Resolution in the v direction.
w_res : int, default: 100
Resolution in the w direction.
clean : bool, default: False
Clean and merge duplicate points to avoid "creases" when
plotting with smooth shading.
texture_coordinates : bool, default: False
The generation of texture coordinates.
This is off by default. Note that this is only applicable
to parametric surfaces whose parametric dimension is 2.
Note that texturing may fail in some cases.
Returns
-------
pyvista.PolyData
Surface from the parametric function.
pyvista.sys
Python Library Documentation: built-in module sys
NAME
sys
MODULE REFERENCE
https://docs.python.org/3.12/library/sys.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
DESCRIPTION
This module provides access to some objects used or maintained by the
interpreter and to functions that interact strongly with the interpreter.
Dynamic objects:
argv -- command line arguments; argv[0] is the script pathname if known
path -- module search path; path[0] is the script directory, else ''
modules -- dictionary of loaded modules
displayhook -- called to show results in an interactive session
excepthook -- called to handle any uncaught exception other than SystemExit
To customize printing in an interactive session or to install a custom
top-level exception handler, assign other functions to replace these.
stdin -- standard input file object; used by input()
stdout -- standard output file object; used by print()
stderr -- standard error object; used for error messages
By assigning other file objects (or objects that behave like files)
to these, it is possible to redirect all of the interpreter's I/O.
last_exc - the last uncaught exception
Only available in an interactive session after a
traceback has been printed.
last_type -- type of last uncaught exception
last_value -- value of last uncaught exception
last_traceback -- traceback of last uncaught exception
These three are the (deprecated) legacy representation of last_exc.
Static objects:
builtin_module_names -- tuple of module names built into this interpreter
copyright -- copyright notice pertaining to this interpreter
exec_prefix -- prefix used to find the machine-specific Python library
executable -- absolute path of the executable binary of the Python interpreter
float_info -- a named tuple with information about the float implementation.
float_repr_style -- string indicating the style of repr() output for floats
hash_info -- a named tuple with information about the hash algorithm.
hexversion -- version information encoded as a single integer
implementation -- Python implementation information.
int_info -- a named tuple with information about the int implementation.
maxsize -- the largest supported length of containers.
maxunicode -- the value of the largest Unicode code point
platform -- platform identifier
prefix -- prefix used to find the Python library
thread_info -- a named tuple with information about the thread implementation.
version -- the version of this interpreter as a string
version_info -- version information as a named tuple
dllhandle -- [Windows only] integer handle of the Python DLL
winver -- [Windows only] version number of the Python DLL
_enablelegacywindowsfsencoding -- [Windows only]
__stdin__ -- the original stdin; don't touch!
__stdout__ -- the original stdout; don't touch!
__stderr__ -- the original stderr; don't touch!
__displayhook__ -- the original displayhook; don't touch!
__excepthook__ -- the original excepthook; don't touch!
Functions:
displayhook() -- print an object to the screen, and save it in builtins._
excepthook() -- print an exception and its traceback to sys.stderr
exception() -- return the current thread's active exception
exc_info() -- return information about the current thread's active exception
exit() -- exit the interpreter by raising SystemExit
getdlopenflags() -- returns flags to be used for dlopen() calls
getprofile() -- get the global profiling function
getrefcount() -- return the reference count for an object (plus one :-)
getrecursionlimit() -- return the max recursion depth for the interpreter
getsizeof() -- return the size of an object in bytes
gettrace() -- get the global debug tracing function
setdlopenflags() -- set the flags to be used for dlopen() calls
setprofile() -- set the global profiling function
setrecursionlimit() -- set the max recursion depth for the interpreter
settrace() -- set the global debug tracing function
SUBMODULES
monitoring
FUNCTIONS
__breakpointhook__ = breakpointhook(...)
breakpointhook(*args, **kws)
This hook function is called by built-in breakpoint().
__displayhook__ = displayhook(object, /)
Print an object to sys.stdout and also save it in builtins._
__excepthook__ = excepthook(exctype, value, traceback, /)
Handle an exception by displaying it with a traceback on sys.stderr.
__unraisablehook__ = unraisablehook(unraisable, /)
Handle an unraisable exception.
The unraisable argument has the following attributes:
* exc_type: Exception type.
* exc_value: Exception value, can be None.
* exc_traceback: Exception traceback, can be None.
* err_msg: Error message, can be None.
* object: Object causing the exception, can be None.
activate_stack_trampoline(backend, /)
Activate stack profiler trampoline *backend*.
addaudithook(hook)
Adds a new audit hook callback.
audit(...)
audit(event, *args)
Passes the event to any audit hooks that are attached.
breakpointhook(...)
breakpointhook(*args, **kws)
This hook function is called by built-in breakpoint().
call_tracing(func, args, /)
Call func(*args), while tracing is enabled.
The tracing state is saved, and restored afterwards. This is intended
to be called from a debugger from a checkpoint, to recursively debug
some other code.
deactivate_stack_trampoline()
Deactivate the current stack profiler trampoline backend.
If no stack profiler is activated, this function has no effect.
displayhook(object, /)
Print an object to sys.stdout and also save it in builtins._
exc_info()
Return current exception information: (type, value, traceback).
Return information about the most recent exception caught by an except
clause in the current stack frame or in an older stack frame.
excepthook(exctype, value, traceback, /)
Handle an exception by displaying it with a traceback on sys.stderr.
exception()
Return the current exception.
Return the most recent exception caught by an except clause
in the current stack frame or in an older stack frame, or None
if no such exception exists.
exit(status=None, /)
Exit the interpreter by raising SystemExit(status).
If the status is omitted or None, it defaults to zero (i.e., success).
If the status is an integer, it will be used as the system exit status.
If it is another kind of object, it will be printed and the system
exit status will be one (i.e., failure).
get_asyncgen_hooks()
Return the installed asynchronous generators hooks.
This returns a namedtuple of the form (firstiter, finalizer).
get_coroutine_origin_tracking_depth()
Check status of origin tracking for coroutine objects in this thread.
get_int_max_str_digits()
Return the maximum string digits limit for non-binary int<->str conversions.
getallocatedblocks()
Return the number of memory blocks currently allocated.
getdefaultencoding()
Return the current default encoding used by the Unicode implementation.
getfilesystemencodeerrors()
Return the error mode used Unicode to OS filename conversion.
getfilesystemencoding()
Return the encoding used to convert Unicode filenames to OS filenames.
getprofile()
Return the profiling function set with sys.setprofile.
See the profiler chapter in the library manual.
getrecursionlimit()
Return the current value of the recursion limit.
The recursion limit is the maximum depth of the Python interpreter
stack. This limit prevents infinite recursion from causing an overflow
of the C stack and crashing Python.
getrefcount(object, /)
Return the reference count of object.
The count returned is generally one higher than you might expect,
because it includes the (temporary) reference as an argument to
getrefcount().
getsizeof(...)
getsizeof(object [, default]) -> int
Return the size of object in bytes.
getswitchinterval()
Return the current thread switch interval; see sys.setswitchinterval().
gettrace()
Return the global debug tracing function set with sys.settrace.
See the debugger chapter in the library manual.
getunicodeinternedsize()
Return the number of elements of the unicode interned dictionary
getwindowsversion()
Return info about the running version of Windows as a named tuple.
The members are named: major, minor, build, platform, service_pack,
service_pack_major, service_pack_minor, suite_mask, product_type and
platform_version. For backward compatibility, only the first 5 items
are available by indexing. All elements are numbers, except
service_pack and platform_type which are strings, and platform_version
which is a 3-tuple. Platform is always 2. Product_type may be 1 for a
workstation, 2 for a domain controller, 3 for a server.
Platform_version is a 3-tuple containing a version number that is
intended for identifying the OS rather than feature detection.
intern(string, /)
``Intern'' the given string.
This enters the string in the (global) table of interned strings whose
purpose is to speed up dictionary lookups. Return the string itself or
the previously interned string object with the same value.
is_finalizing()
Return True if Python is exiting.
is_stack_trampoline_active()
Return *True* if a stack profiler trampoline is active.
set_asyncgen_hooks(...)
set_asyncgen_hooks([firstiter] [, finalizer])
Set a finalizer for async generators objects.
set_coroutine_origin_tracking_depth(depth)
Enable or disable origin tracking for coroutine objects in this thread.
Coroutine objects will track 'depth' frames of traceback information
about where they came from, available in their cr_origin attribute.
Set a depth of 0 to disable.
set_int_max_str_digits(maxdigits)
Set the maximum string digits limit for non-binary int<->str conversions.
setprofile(...)
setprofile(function)
Set the profiling function. It will be called on each function call
and return. See the profiler chapter in the library manual.
setrecursionlimit(limit, /)
Set the maximum depth of the Python interpreter stack to n.
This limit prevents infinite recursion from causing an overflow of the C
stack and crashing Python. The highest possible limit is platform-
dependent.
setswitchinterval(interval, /)
Set the ideal thread switching delay inside the Python interpreter.
The actual frequency of switching threads can be lower if the
interpreter executes long sequences of uninterruptible code
(this is implementation-specific and workload-dependent).
The parameter must represent the desired switching delay in seconds
A typical value is 0.005 (5 milliseconds).
settrace(...)
settrace(function)
Set the global debug tracing function. It will be called on each
function call. See the debugger chapter in the library manual.
unraisablehook(unraisable, /)
Handle an unraisable exception.
The unraisable argument has the following attributes:
* exc_type: Exception type.
* exc_value: Exception value, can be None.
* exc_traceback: Exception traceback, can be None.
* err_msg: Error message, can be None.
* object: Object causing the exception, can be None.
DATA
__stderr__ = <_io.TextIOWrapper name='<stderr>' mode='w' encoding='cp1...
__stdin__ = <_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8...
__stdout__ = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='cp1...
api_version = 1013
argv = [r'f:\JoeyCodes\PyDocs\py_docs.py', '--worker', 'pyvista', r'F:...
base_exec_prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Pyth...
base_prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312...
builtin_module_names = ('_abc', '_ast', '_bisect', '_blake2', '_codecs...
byteorder = 'little'
copyright = 'Copyright (c) 2001-2023 Python Software Foundati...ematis...
dllhandle = 140727031824384
dont_write_bytecode = False
exec_prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312...
executable = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312\...
flags = sys.flags(debug=0, inspect=0, interactive=0, opt...ding=0, saf...
float_info = sys.float_info(max=1.7976931348623157e+308, max_...epsilo...
float_repr_style = 'short'
hash_info = sys.hash_info(width=64, modulus=2305843009213693...iphash1...
hexversion = 51119856
implementation = namespace(name='cpython', cache_tag='cpython-312...as...
int_info = sys.int_info(bits_per_digit=30, sizeof_digit=4, ..._str_dig...
maxsize = 9223372036854775807
maxunicode = 1114111
meta_path = [<vtkmodules.VTKMetaHook object>, <_distutils_hack.Distuti...
modules = {'__future__': <module '__future__' from 'C:\\Users\\Youse\\...
orig_argv = [r'C:\Users\Youse\AppData\Local\Programs\Python\Python312\...
path = [r'f:\JoeyCodes\PyDocs', r'C:\Users\Youse\AppData\Local\Program...
path_hooks = [<class 'zipimport.zipimporter'>, <function FileFinder.pa...
path_importer_cache = {r'C:\Users\Youse\AppData\Local\Programs\Python\...
platform = 'win32'
platlibdir = 'DLLs'
prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312'
pycache_prefix = None
stderr = <_io.TextIOWrapper name='<stderr>' mode='w' encoding='cp1252'...
stdin = <_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8'>
stdlib_module_names = frozenset({'__future__', '_abc', '_aix_support',...
stdout = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='cp1252'...
thread_info = sys.thread_info(name='nt', lock=None, version=None)
version = '3.12.6 (tags/v3.12.6:a4a2d2b, Sep 6 2024, 20:11:23) [MSC v...
version_info = sys.version_info(major=3, minor=12, micro=6, releaselev...
warnoptions = []
winver = '3.12'
FILE
(built-in)
pyvista.threaded
Python Library Documentation: function threaded in module pyvista.core.utilities.misc
threaded(fn)
Call a function using a thread.
Parameters
----------
fn : callable
Callable object.
Returns
-------
function
Wrapped function.
pyvista.to_meshio
Python Library Documentation: function to_meshio in module pyvista.core.utilities.fileio
to_meshio(mesh: 'DataSet') -> 'meshio.Mesh'
Convert a PyVista mesh to a ``meshio`` mesh instance.
.. versionadded:: 0.45
Parameters
----------
mesh : pyvista.DataSet
Any PyVista mesh/spatial data type.
Returns
-------
meshio.Mesh
A mesh instance from the ``meshio`` library.
Raises
------
ImportError
If the meshio package is not installed.
See Also
--------
from_meshio, read_meshio, save_meshio, :func:`~pyvista.wrap`
Examples
--------
Convert a pyvista sphere to a ``meshio`` mesh instance.
>>> import pyvista as pv
>>> sphere = pv.Sphere()
>>> mesh = pv.to_meshio(sphere)
pyvista.to_trimesh
Python Library Documentation: function to_trimesh in module pyvista.core.utilities.fileio
to_trimesh(mesh: 'DataSet', *, triangulate: 'bool' = False, pass_data: '_PassDataOptions' = True) -> 'trimesh.Trimesh'
Convert a PyVista mesh to a Trimesh mesh.
- Point data is stored as ``vertex_attributes``.
- Cell data is stored as ``face_attributes``.
- Field data is stored as ``metadata``. Any :attr:`~pyvista.DataObject.user_dict` keys
are stored directly as metadata.
.. note::
No copies of point, cell, or data arrays are made. Use :meth:`~pyvista.DataObject.copy`
before converting to avoid any side effects.
.. versionadded:: 0.47
Parameters
----------
mesh : DataSet
Dataset to convert.
triangulate : bool, default: False
Triangulate the mesh before conversion. If the mesh has 3D cells, the mesh's surface
is extracted. All 2D polygonal cells are triangulated as required, and all 0D and 1D
cells or any unused points are ignored.
pass_data : bool | str | sequence[str], default: True
Pass point, cell, and/or field data to the Trimesh object. All data is passed by default.
Set this to ``'point'``, ``'cell'``, ``'field'`` or any combination thereof to only pass
specific fields.
See Also
--------
from_trimesh, to_meshio, :func:`~pyvista.wrap`
Examples
--------
See :ref:`wrap_trimesh_example` for examples.
pyvista.transform
Python Library Documentation: module pyvista.core.utilities.transform in pyvista.core.utilities
NAME
pyvista.core.utilities.transform - Module containing the Transform class.
CLASSES
pyvista.core._vtk_utilities.DisableVtkSnakeCase(builtins.object)
Transform(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride, vtkmodules.vtkCommonTransforms.vtkTransform)
pyvista.core._vtk_utilities.vtkPyVistaOverride(builtins.object)
Transform(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride, vtkmodules.vtkCommonTransforms.vtkTransform)
pyvista.core.utilities.misc._NoNewAttrMixin(builtins.object)
Transform(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride, vtkmodules.vtkCommonTransforms.vtkTransform)
vtkmodules.vtkCommonTransforms.vtkTransform(vtkmodules.vtkCommonTransforms.vtkLinearTransform)
Transform(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride, vtkmodules.vtkCommonTransforms.vtkTransform)
class Transform(pyvista.core.utilities.misc._NoNewAttrMixin, pyvista.core._vtk_utilities.DisableVtkSnakeCase, pyvista.core._vtk_utilities.vtkPyVistaOverride, vtkmodules.vtkCommonTransforms.vtkTransform)
| Transform(*args, **kwargs) -> '_T'
|
| Describes linear transformations via a 4x4 matrix.
|
| A :class:`Transform` can be used to describe the full range of linear (also known
| as affine) coordinate transformations in three dimensions, which are internally
| represented as a 4x4 homogeneous transformation matrix.
|
| The transformation methods (e.g. :meth:`translate`, :meth:`rotate`,
| :meth:`compose`) can operate in either :meth:`pre_multiply` or
| :meth:`post_multiply` mode. In pre-multiply mode, any additional transformations
| will occur *before* any transformations represented by the current :attr:`matrix`.
| In post-multiply mode (the default), the additional transformation will occur
| *after* any transformations represented by the current matrix.
|
| .. note::
|
| This class performs all of its operations in a right-handed coordinate system
| with right-handed rotations. Some other graphics libraries use left-handed
| coordinate systems and rotations.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| trans : TransformLike | Sequence[TransformLike], optional
| Initialize the transform with a transformation or sequence of transformations.
| By default, the transform is initialized as the identity matrix.
|
| point : VectorLike[float], optional
| Point to use when composing transformations.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the transformation
| - :meth:`translate` away from ``point`` after the transformation
|
| By default, this value is ``None``, which means that the scale, rotation, etc.
| transformations are performed about the origin ``(0, 0, 0)``.
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing. Set this to ``'pre'`` for
| pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| pyvista.DataObjectFilters.transform
| Apply a transformation to a mesh.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Create a transformation and use ``+`` to compose a translation.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> position = (-0.6, -0.8, 2.1)
| >>> translation_T = pv.Transform() + position
| >>> translation_T.matrix
| array([[ 1. , 0. , 0. , -0.6],
| [ 0. , 1. , 0. , -0.8],
| [ 0. , 0. , 1. , 2.1],
| [ 0. , 0. , 0. , 1. ]])
|
| Using ``+`` performs the same concatenation as calling :meth:`translate`.
|
| >>> np.array_equal(
| ... translation_T.matrix, pv.Transform().translate(position).matrix
| ... )
| True
|
| Create a transformation and use ``*`` to compose a scaling matrix.
|
| >>> scale_factor = 2.0
| >>> scaling_T = pv.Transform() * scale_factor
| >>> scaling_T.matrix
| array([[2., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 2., 0.],
| [0., 0., 0., 1.]])
|
| Using ``*`` performs the same concatenation as calling :meth:`scale`.
|
| >>> np.array_equal(scaling_T.matrix, pv.Transform().scale(scale_factor).matrix)
| True
|
| Compose the two transformations using ``*``. This will compose with
| post-multiplication such that the transformations are applied in order from left to
| right, i.e. translate first, then scale.
|
| >>> transform_post = translation_T * scaling_T
| >>> transform_post.matrix
| array([[ 2. , 0. , 0. , -1.2],
| [ 0. , 2. , 0. , -1.6],
| [ 0. , 0. , 2. , 4.2],
| [ 0. , 0. , 0. , 1. ]])
|
| Post-multiplication is equivalent to using matrix multiplication on the
| arrays directly but with the arguments reversed:
|
| >>> mat_mul = scaling_T.matrix @ translation_T.matrix
| >>> np.array_equal(transform_post.matrix, mat_mul)
| True
|
| Alternatively, compose the transformations by chaining the methods with a
| single :class:`Transform` instance. Note that post-multiply is used by default.
|
| >>> transform_post = pv.Transform()
| >>> transform_post.multiply_mode
| 'post'
| >>> _ = transform_post.translate(position).scale(scale_factor)
| >>> transform_post.matrix
| array([[ 2. , 0. , 0. , -1.2],
| [ 0. , 2. , 0. , -1.6],
| [ 0. , 0. , 2. , 4.2],
| [ 0. , 0. , 0. , 1. ]])
|
| Use :attr:`n_transformations` to check that there are two transformations.
|
| >>> transform_post.n_transformations
| 2
|
| Use :attr:`matrix_list` to get a list of the transformations. Since
| post-multiplication is used, the translation matrix is first in the list since
| it was applied first, and the scale matrix is second.
|
| >>> transform_post.matrix_list[0] # translation
| array([[ 1. , 0. , 0. , -0.6],
| [ 0. , 1. , 0. , -0.8],
| [ 0. , 0. , 1. , 2.1],
| [ 0. , 0. , 0. , 1. ]])
|
| >>> transform_post.matrix_list[1] # scaling
| array([[2., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 2., 0.],
| [0., 0., 0., 1.]])
|
| Create a similar transform but use pre-multiplication this time. Compose the
| transformations in the same order as before using :meth:`translate` and :meth:`scale`.
|
| >>> transform_pre = pv.Transform().pre_multiply()
| >>> _ = transform_pre.translate(position).scale(scale_factor)
|
| This is equivalent to using matrix multiplication directly on the arrays:
|
| >>> mat_mul = translation_T.matrix @ scaling_T.matrix
| >>> np.array_equal(transform_pre.matrix, mat_mul)
| True
|
| Show the matrix list again. Note how the order with pre-multiplication is the
| reverse of post-multiplication.
|
| >>> transform_pre.matrix_list[0] # scaling
| array([[2., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 2., 0.],
| [0., 0., 0., 1.]])
|
| >>> transform_pre.matrix_list[1] # translation
| array([[ 1. , 0. , 0. , -0.6],
| [ 0. , 1. , 0. , -0.8],
| [ 0. , 0. , 1. , 2.1],
| [ 0. , 0. , 0. , 1. ]])
|
| Apply the two post- and pre-multiplied transformations to a dataset and plot them.
| Note how the meshes have different positions since post- and pre-multiplication
| produce different transformations.
|
| >>> mesh_post = pv.Sphere().transform(transform_post, inplace=False)
| >>> mesh_pre = pv.Cone().transform(transform_pre, inplace=False)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh_post, color='goldenrod')
| >>> _ = pl.add_mesh(mesh_pre, color='teal')
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| Get the composed inverse transformation matrix of the pre-multiplication case.
|
| >>> inverse_matrix = transform_pre.inverse_matrix
| >>> inverse_matrix
| array([[ 0.5 , 0. , 0. , 0.3 ],
| [ 0. , 0.5 , 0. , 0.4 ],
| [ 0. , 0. , 0.5 , -1.05],
| [ 0. , 0. , 0. , 1. ]])
|
| Similar to using :attr:`matrix_list`, we can inspect the individual transformation
| inverses with :attr:`inverse_matrix_list`.
|
| >>> transform_pre.inverse_matrix_list[0] # inverse scaling
| array([[0.5, 0. , 0. , 0. ],
| [0. , 0.5, 0. , 0. ],
| [0. , 0. , 0.5, 0. ],
| [0. , 0. , 0. , 1. ]])
|
| >>> transform_pre.inverse_matrix_list[1] # inverse translation
| array([[ 1. , 0. , 0. , 0.6],
| [ 0. , 1. , 0. , 0.8],
| [ 0. , 0. , 1. , -2.1],
| [ 0. , 0. , 0. , 1. ]])
|
| Transform the mesh by its inverse to restore it to its original un-scaled state
| and positioning at the origin.
|
| >>> mesh_pre_inverted = mesh_pre.transform(inverse_matrix, inplace=False)
| >>> pl = pv.Plotter()
| >>> _ = pl.add_mesh(mesh_pre_inverted, color='teal')
| >>> _ = pl.add_axes_at_origin()
| >>> pl.show()
|
| Method resolution order:
| Transform
| pyvista.core.utilities.misc._NoNewAttrMixin
| pyvista.core._vtk_utilities.DisableVtkSnakeCase
| pyvista.core._vtk_utilities.vtkPyVistaOverride
| vtkmodules.vtkCommonTransforms.vtkTransform
| vtkmodules.vtkCommonTransforms.vtkLinearTransform
| vtkmodules.vtkCommonTransforms.vtkHomogeneousTransform
| vtkmodules.vtkCommonTransforms.vtkAbstractTransform
| vtkmodules.vtkCommonCore.vtkObject
| vtkmodules.vtkCommonCore.vtkObjectBase
| builtins.object
|
| Methods defined here:
|
| __add__(self: 'Transform', other: 'VectorLike[float]') -> 'Transform'
| :meth:`translate` this transform using post-multiply semantics.
|
| __init__(self: 'Transform', trans: 'TransformLike | Sequence[TransformLike] | None' = None, *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post']" = 'post') -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __mul__(self: 'Transform', other: 'float | VectorLike[float] | TransformLike') -> 'Transform'
| :meth:`compose` this transform using post-multiply semantics.
|
| Use :meth:`scale` for single numbers and length-3 vector inputs, and
| :meth:`compose` otherwise for transform-like inputs.
|
| __radd__(self: 'Transform', other: 'VectorLike[float]') -> 'Transform'
| :meth:`translate` this transform using pre-multiply semantics.
|
| __repr__(self: 'Transform') -> 'str'
| Representation of the transform.
|
| __rmul__(self: 'Transform', other: 'float | VectorLike[float]') -> 'Transform'
| :meth:`scale` this transform using pre-multiply semantics.
|
| apply(self: 'Transform', obj: 'VectorLike[float] | MatrixLike[float] | DataSet | MultiBlock | Prop3D', /, mode: "Literal['points', 'vectors', 'active_vectors', 'all_vectors', 'replace', 'pre-multiply', 'post-multiply'] | None" = None, *, inverse: 'bool' = False, copy: 'bool' = True)
| Apply the current transformation :attr:`~Transform.matrix` to points, vectors, a dataset, or actor.
|
| .. note::
|
| Points with integer values are cast to a float type before the
| transformation is applied. A similar casting is also performed when
| transforming datasets. See also the notes at
| :func:`~pyvista.DataObjectFilters.transform`
| which is used by this filter under the hood.
|
| Parameters
| ----------
| obj : VectorLike[float] | MatrixLike[float] | DataSet | MultiBlock | Prop3D
| Object to apply the transformation to.
|
| mode : str, optional
| Define how to apply the transformation. Different modes may be used depending
| on the input type.
|
| #. For array inputs:
|
| - ``'points'`` transforms point arrays.
| - ``'vectors'`` transforms vector arrays. The translation component of
| the transformation is removed for vectors.
|
| By default, ``'points'`` mode is used for array inputs.
|
| #. For dataset inputs:
|
| The dataset's points are always transformed, and its vectors are
| transformed based on the mode:
|
| - ``'active_vectors'`` transforms active normals and active vectors
| arrays only.
| - ``'all_vectors'`` transforms `all` input vectors, i.e. all arrays
| with three components. This mode is equivalent to setting
| ``transform_all_input_vectors=True``
| with :meth:`pyvista.DataObjectFilters.transform`.
|
| By default, only ``'active_vectors'`` are transformed.
|
| #. For actor inputs:
|
| - ``'pre-multiply'`` pre-multiplies this transform with the actor's
| :attr:`~pyvista.Prop3D.user_matrix`.
| - ``'post-multiply'`` post-multiplies this transform with the actor's
| user-matrix.
| - ``'replace'`` replaces the actor's user-matrix with this transform's
| :attr:`matrix`.
|
| By default, ``'post-multiply'`` mode is used for actors.
|
| inverse : bool, default: False
| Apply the transformation using the :attr:`inverse_matrix` instead of the
| :attr:`matrix`.
|
| copy : bool, default: True
| Return a copy of the input with the transformation applied. Set this to
| ``False`` to transform the input directly and return it. Setting this to
| ``False`` only applies to NumPy float arrays, datasets, and actors; a copy
| is always returned for tuple and list inputs or arrays with integers.
|
| Returns
| -------
| output : np.ndarray | DataSet | MultiBlock | Prop3D
| Transformed array, dataset, or actor.
|
| See Also
| --------
| apply_to_points
| Equivalent to ``apply(obj, 'points')`` for point-array inputs.
| apply_to_vectors
| Equivalent to ``apply(obj, 'vectors')`` for vector-array inputs.
| apply_to_dataset
| Equivalent to ``apply(obj, mode)`` for dataset inputs where ``mode`` may be
| ``'active_vectors'`` or ``'all_vectors'``.
| apply_to_actor
| Equivalent to ``apply(obj, mode)`` for actor inputs where ``mode`` may be
| ``'pre-multiply'``, ``'post-multiply'``, or ``'replace'``.
| pyvista.DataObjectFilters.transform
| Transform a dataset.
| pyvista.Prop3D.transform
| Transform an actor.
|
| Examples
| --------
| Apply a transformation to a point.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> point = (1.0, 2.0, 3.0)
| >>> transform = pv.Transform().scale(2).translate((0.0, 0.0, 1.0))
| >>> transformed = transform.apply(point)
| >>> transformed
| array([2., 4., 7.])
|
| Apply a transformation to a points array.
|
| >>> array = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
| >>> transformed = transform.apply(array)
| >>> transformed
| array([[ 2., 4., 7.],
| [ 8., 10., 13.]])
|
| Apply a transformation to a vector array. Use the same array as before but
| use the ``'vectors'`` mode. Note how the translation component is not applied
| to vectors.
|
| >>> transformed = transform.apply(array, 'vectors')
| >>> transformed
| array([[ 2., 4., 6.],
| [ 8., 10., 12.]])
|
| Apply a transformation to a dataset.
|
| >>> dataset = pv.PolyData(array)
| >>> transformed = transform.apply(dataset)
| >>> transformed.points
| pyvista_ndarray([[ 2., 4., 6.],
| [ 8., 10., 12.]])
|
| Apply the inverse.
|
| >>> transformed = transform.apply(dataset, inverse=True)
| >>> transformed.points
| pyvista_ndarray([[0.5, 1. , 1. ],
| [2. , 2.5, 2.5]])
|
| Apply a transformation to an actor.
|
| >>> actor = pv.Actor()
| >>> transformed_actor = transform.apply(actor)
| >>> transformed_actor.user_matrix
| array([[2., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 2., 0.],
| [0., 0., 0., 1.]])
|
| apply_to_actor(self, actor: 'Prop3D', /, mode: "Literal['pre-multiply', 'post-multiply', 'replace']" = 'post-multiply', *, copy: 'bool' = True, inverse: 'bool' = False) -> 'Prop3D'
| Apply the current transformation :attr:`~Transform.matrix` to an actor.
|
| This is equivalent to ``apply(actor, mode)``. See :meth:`apply` for details and
| examples.
|
| Parameters
| ----------
| actor : Prop3D
| Actor to apply the transformation to.
|
| mode : 'pre-multiply', 'post-multiply', 'replace', default: 'post-multiply'
| Mode for transforming the actor:
|
| - ``'pre-multiply'`` pre-multiplies this transform with the actor's
| :attr:`~pyvista.Prop3D.user_matrix`.
| - ``'post-multiply'`` post-multiplies this transform with the actor's
| user-matrix.
| - ``'replace'`` replaces the actor's user-matrix with this transform's
| :attr:`matrix`.
|
| By default, ``'post-multiply'`` mode is used.
|
| inverse : bool, default: False
| Apply the transformation using the :attr:`inverse_matrix` instead of the
| :attr:`matrix`.
|
| copy : bool, default: True
| Return a copy of the input with the transformation applied. Set this to
| ``False`` to transform the input directly and return it.
|
| Returns
| -------
| Prop3D
| Transformed actor.
|
| See Also
| --------
| apply
| Apply this transformation to any input.
| apply_to_points
| Apply this transformation to points.
| apply_to_vectors
| Apply this transformation to vectors.
| apply_to_dataset
| Apply this transformation to a dataset.
| pyvista.Prop3D.transform
| Transform an actor.
|
| apply_to_dataset(self, dataset: '_DataSetOrMultiBlockType', /, mode: "Literal['active_vectors', 'all_vectors']" = 'active_vectors', *, copy: 'bool' = True, inverse: 'bool' = False) -> '_DataSetOrMultiBlockType'
| Apply the current transformation :attr:`~Transform.matrix` to a dataset.
|
| This is equivalent to ``apply(dataset, mode)``. See :meth:`apply` for details
| and examples.
|
| Parameters
| ----------
| dataset : DataSet | MultiBlock
| Object to apply the transformation to.
|
| mode : 'active_vectors' | 'all_vectors', default: 'active_vectors'
| Mode for transforming the dataset's vectors:
|
| - ``'active_vectors'`` transforms active normals and active vectors arrays
| only.
| - ``'all_vectors'`` transforms `all` input vectors, i.e. all arrays with
| three components. This mode is equivalent to setting
| ``transform_all_input_vectors=True``
| with :meth:`pyvista.DataObjectFilters.transform`.
|
| inverse : bool, default: False
| Apply the transformation using the :attr:`inverse_matrix` instead of the
| :attr:`matrix`.
|
| copy : bool, default: True
| Return a copy of the input with the transformation applied. Set this to
| ``False`` to transform the input directly and return it.
|
| Returns
| -------
| output : DataSet | MultiBlock
| Transformed dataset.
|
| See Also
| --------
| apply
| Apply this transformation to any input.
| apply_to_points
| Apply this transformation to points.
| apply_to_vectors
| Apply this transformation to vectors.
| apply_to_actor
| Apply this transformation to an actor.
| pyvista.DataObjectFilters.transform
| Transform a dataset.
|
| apply_to_points(self, points: 'VectorLike[float] | MatrixLike[float]', /, *, inverse: 'bool' = False, copy: 'bool' = True) -> 'NumpyArray[float]'
| Apply the current transformation :attr:`~Transform.matrix` to a point or points.
|
| This is equivalent to ``apply(points, 'points')``. See :meth:`apply` for
| details and examples.
|
| Parameters
| ----------
| points : VectorLike[float] | MatrixLike[float]
| Single point or ``Nx3`` points array to apply the transformation to.
|
| inverse : bool, default: False
| Apply the transformation using the :attr:`inverse_matrix` instead of the
| :attr:`matrix`.
|
| copy : bool, default: True
| Return a copy of the input with the transformation applied. Set this to
| ``False`` to transform the input directly and return it. Only applies to
| NumPy arrays. A copy is always returned for tuple and list
| inputs or point arrays with integers.
|
| Returns
| -------
| np.ndarray
| Transformed points.
|
| See Also
| --------
| apply
| Apply this transformation to any input.
| apply_to_vectors
| Apply this transformation to vectors.
| apply_to_dataset
| Apply this transformation to a dataset.
| apply_to_actor
| Apply this transformation to an actor.
|
| apply_to_vectors(self, vectors: 'VectorLike[float] | MatrixLike[float]', /, *, inverse: 'bool' = False, copy: 'bool' = True) -> 'NumpyArray[float]'
| Apply the current transformation :attr:`~Transform.matrix` to a vector or vectors.
|
| This is equivalent to ``apply(vectors, 'vectors')``. See :meth:`apply` for
| details and examples.
|
| Parameters
| ----------
| vectors : VectorLike[float] | MatrixLike[float]
| Single vector or ``Nx3`` vectors array to apply the transformation to.
|
| inverse : bool, default: False
| Apply the transformation using the :attr:`inverse_matrix` instead of the
| :attr:`matrix`.
|
| copy : bool, default: True
| Return a copy of the input with the transformation applied. Set this to
| ``False`` to transform the input directly and return it. Only applies to
| NumPy arrays. A copy is always returned for tuple and list
| inputs or point arrays with integers.
|
| Returns
| -------
| np.ndarray
| Transformed vectors.
|
| See Also
| --------
| apply
| Apply this transformation to any input.
| apply_to_points
| Apply this transformation to points.
| apply_to_dataset
| Apply this transformation to a dataset.
| apply_to_actor
| Apply this transformation to an actor.
|
| as_rotation(self, representation: "Literal['quat', 'matrix', 'rotvec', 'mrp', 'euler', 'davenport'] | None" = None, *args, **kwargs) -> 'Rotation | NumpyArray[float]'
| Return the rotation component as a SciPy ``Rotation`` or any of its representations.
|
| The current :attr:`matrix` is first decomposed to extract the rotation component
| and then returned with the specified representation.
|
| .. note::
|
| This method depends on the ``scipy`` package which must be installed to use it.
|
| Parameters
| ----------
| representation : str, optional
| Representation of the rotation.
|
| - ``'quat'``: Represent as a quaternion using
| :meth:`~scipy.spatial.transform.Rotation.as_quat`. Returns a length-4 vector.
| - ``'matrix'``: Represent as a 3x3 matrix using
| :meth:`~scipy.spatial.transform.Rotation.as_matrix`.
| - ``'rotvec'``: Represent as a rotation vector using
| :meth:`~scipy.spatial.transform.Rotation.as_rotvec`.
| - ``'mrp'``: Represent as a Modified Rodrigues Parameters (MRPs) vector using
| :meth:`~scipy.spatial.transform.Rotation.as_mrp`.
| - ``'euler'``: Represent as Euler angles using
| :meth:`~scipy.spatial.transform.Rotation.as_euler`.
| - ``'davenport'``: Represent as Davenport angles using
| :meth:`~scipy.spatial.transform.Rotation.as_davenport`.
|
| If no representation is given, then an instance of
| :class:`scipy.spatial.transform.Rotation` is returned by default.
|
| *args
| Arguments passed to the ``Rotation`` method for the specified
| representation.
|
| **kwargs
| Keyword arguments passed to the ``Rotation`` method for the specified
| representation.
|
| Returns
| -------
| output : scipy.spatial.transform.Rotation | np.ndarray
| Rotation object or array depending on the representation.
|
| See Also
| --------
| rotation_matrix, rotation_axis_angle, decompose
| Get this transform's rotation component `without` using SciPy.
| rotate, rotate_x, rotate_y, rotate_z, rotate_vector
| Compose a rotation matrix.
|
| Examples
| --------
| Create a rotation matrix and initialize a :class:`Transform` from it.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> matrix = [[0, -1, 0], [1, 0, 0], [0, 0, 1]]
| >>> transform = pv.Transform(matrix)
|
| Represent the rotation as :class:`scipy.spatial.transform.Rotation` instance.
|
| >>> rot = transform.as_rotation()
| >>> type(rot)
| <class 'scipy.spatial.transform._rotation.Rotation'>
|
| Represent the rotation as a quaternion.
|
| >>> rot = transform.as_rotation('quat')
| >>> rot
| array([0. , 0. , 0.70710678, 0.70710678])
|
| Represent the rotation as a rotation vector. The vector has a direction
| ``(0, 0, 1)`` and magnitude of ``pi/2``.
|
| >>> rot = transform.as_rotation('rotvec')
| >>> rot
| array([0. , 0. , 1.57079633])
|
| Represent the rotation as a Modified Rodrigues Parameters vector.
|
| >>> rot = transform.as_rotation('mrp')
| >>> rot
| array([0. , 0. , 0.41421356])
|
| Represent the rotation as x-y-z Euler angles in degrees.
|
| >>> rot = transform.as_rotation('euler', 'xyz', degrees=True)
| >>> rot
| array([ 0., 0., 90.])
|
| Represent the rotation as extrinsic x-y-z Davenport angles in degrees.
|
| >>> rot = transform.as_rotation(
| ... 'davenport', np.eye(3), 'extrinsic', degrees=True
| ... )
| >>> rot
| array([-1.27222187e-14, 0.00000000e+00, 9.00000000e+01])
|
| compose(self: 'Transform', transform: 'TransformLike', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a transformation matrix.
|
| Create a 4x4 matrix from any transform-like input and compose it with the
| current transformation :attr:`matrix` according to pre-multiply or post-multiply
| semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| transform : TransformLike
| Any transform-like input such as a 3x3 or 4x4 array or matrix.
|
| point : VectorLike[float], optional
| Point to transform about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the transformation
| - :meth:`translate` away from ``point`` after the transformation
|
| .. versionadded:: 0.47
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| decompose
|
| Examples
| --------
| Define an arbitrary 4x4 affine transformation matrix and compose it.
|
| >>> import pyvista as pv
| >>> array = [
| ... [0.707, -0.707, 0, 0],
| ... [0.707, 0.707, 0, 0],
| ... [0, 0, 1, 1.5],
| ... [0, 0, 0, 2],
| ... ]
| >>> transform = pv.Transform().compose(array)
| >>> transform.matrix
| array([[ 0.707, -0.707, 0. , 0. ],
| [ 0.707, 0.707, 0. , 0. ],
| [ 0. , 0. , 1. , 1.5 ],
| [ 0. , 0. , 0. , 2. ]])
|
| Define a second transformation and use ``*`` to compose it.
|
| >>> array = [[1, 0, 0], [0, 0, -1], [0, -1, 0]]
| >>> transform = transform * array
| >>> transform.matrix
| array([[ 0.707, -0.707, 0. , 0. ],
| [ 0. , 0. , -1. , -1.5 ],
| [-0.707, -0.707, 0. , 0. ],
| [ 0. , 0. , 0. , 2. ]])
|
| Compose the transform about a point. Check the :attr:`matrix_list` to see that a
| translation is added before and after the transform.
|
| >>> transform = pv.Transform().compose(transform, point=(1, 2, 3))
| >>> transform.matrix_list # doctest: +NORMALIZE_WHITESPACE
| [array([[ 1., 0., 0., -1.],
| [ 0., 1., 0., -2.],
| [ 0., 0., 1., -3.],
| [ 0., 0., 0., 1.]]),
| array([[ 0.707, -0.707, 0. , 0. ],
| [ 0. , 0. , -1. , -1.5 ],
| [-0.707, -0.707, 0. , 0. ],
| [ 0. , 0. , 0. , 2. ]]),
| array([[1., 0., 0., 1.],
| [0., 1., 0., 2.],
| [0., 0., 1., 3.],
| [0., 0., 0., 1.]])]
|
| copy(self: 'Transform') -> 'Transform'
| Return a deep copy of the transform.
|
| Returns
| -------
| Transform
| Deep copy of this transform.
|
| Examples
| --------
| Create a scaling transform.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().scale(1, 2, 3)
| >>> transform.matrix
| array([[1., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 3., 0.],
| [0., 0., 0., 1.]])
|
| Copy the transform.
|
| >>> copied = transform.copy()
| >>> copied.matrix
| array([[1., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 3., 0.],
| [0., 0., 0., 1.]])
|
| >>> copied is transform
| False
|
| decompose(self: 'Transform', *, homogeneous: 'bool' = False) -> '_FiveArrays'
| Decompose the current transformation into its components.
|
| Decompose the :attr:`matrix` ``M`` into
|
| - translation ``T``
| - rotation ``R``
| - reflection ``N``
| - scaling ``S``
| - shearing ``K``
|
| such that, when represented as 4x4 matrices, ``M = TRNSK``. The decomposition is
| unique and is computed with polar matrix decomposition.
|
| By default, compact representations of the transformations are returned (e.g. as a
| 3-element vector or a 3x3 matrix). Optionally, 4x4 matrices may be returned instead.
|
| .. note::
|
| - The rotation is orthonormal and right-handed with positive determinant.
| - The scaling factors are positive.
| - The reflection is either ``1`` (no reflection) or ``-1`` (has reflection)
| and can be used like a scaling factor.
|
| Parameters
| ----------
| homogeneous : bool, default: False
| If ``True``, return the components (translation, rotation, etc.) as 4x4
| homogeneous matrices. By default, reflection is a scalar, translation and
| scaling are length-3 vectors, and rotation and shear are 3x3 matrices.
|
| Returns
| -------
| numpy.ndarray
| Translation component ``T``. Returned as a 3-element vector (or a 4x4
| translation matrix if ``homogeneous`` is ``True``).
|
| numpy.ndarray
| Rotation component ``R``. Returned as a 3x3 orthonormal rotation matrix of row
| vectors (or a 4x4 rotation matrix if ``homogeneous`` is ``True``).
|
| numpy.ndarray
| Reflection component ``N``. Returned as a NumPy scalar (or a 4x4 reflection
| matrix if ``homogeneous`` is ``True``).
|
| numpy.ndarray
| Scaling component ``S``. Returned as a 3-element vector (or a 4x4 scaling matrix
| if ``homogeneous`` is ``True``).
|
| numpy.ndarray
| Shear component ``K``. Returned as a 3x3 matrix with ones on the diagonal and
| shear values in the off-diagonals (or as a 4x4 shearing matrix if ``homogeneous``
| is ``True``).
|
| See Also
| --------
| compose
| Compose a transformation.
|
| translation, has_translation
| Get info about this transform's translation component.
|
| rotation_matrix, rotation_axis_angle, as_rotation, has_rotation
| Get info about this transform's rotation component.
|
| reflection, has_reflection
| Get info about this transform's reflection component.
|
| scale_factors, has_scale
| Get info about this transform's scale component.
|
| shear_matrix, has_shear
| Get info about this transform's shear component.
|
| Examples
| --------
| Create a transform by composing scaling, rotation, and translation
| matrices.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> transform = pv.Transform()
| >>> _ = transform.scale(1, 2, 3)
| >>> _ = transform.rotate_z(90)
| >>> _ = transform.translate(4, 5, 6)
| >>> transform
| Transform (...)
| Num Transformations: 3
| Matrix: [[ 0., -2., 0., 4.],
| [ 1., 0., 0., 5.],
| [ 0., 0., 3., 6.],
| [ 0., 0., 0., 1.]]
|
| Decompose the matrix.
|
| >>> T, R, N, S, K = transform.decompose()
|
| Since the input has no shear this component is the identity matrix.
| Similarly, there are no reflections so its value is ``1``. All other components
| are recovered perfectly and match the input.
|
| >>> K # shear
| array([[1., 0., 0.],
| [0., 1., 0.],
| [0., 0., 1.]])
|
| >>> S # scale
| array([1., 2., 3.])
|
| >>> N # reflection
| array(1.)
|
| >>> R # rotation
| array([[ 0., -1., 0.],
| [ 1., 0., 0.],
| [ 0., 0., 1.]])
|
| >>> T # translation
| array([4., 5., 6.])
|
| Compose a shear component using pre-multiplication so that shearing is
| the first transformation.
|
| >>> shear = np.eye(4)
| >>> shear[0, 1] = 0.1 # xy shear
| >>> _ = transform.compose(shear, multiply_mode='pre')
|
| Repeat the decomposition and show its components. Note how the decomposed shear
| does not perfectly match the input shear matrix values. The values of the
| scaling and rotation components are also affected and do not exactly match the
| input. This is expected, because the shear can be partially factored as a
| combination of rotation and scaling.
|
| >>> T, R, N, S, K = transform.decompose()
|
| >>> K # shear
| array([[1. , 0.03333333, 0. ],
| [0.01663894, 1. , 0. ],
| [0. , 0. , 1. ]])
|
| >>> S # scale
| array([0.99944491, 2.0022213 , 3. ])
|
| >>> N # reflection
| array(1.)
|
| >>> R # rotation
| array([[ 0.03331483, -0.99944491, 0. ],
| [ 0.99944491, 0.03331483, 0. ],
| [ 0. , 0. , 1. ]])
|
| >>> T # translation
| array([4., 5., 6.])
|
| Although the values may not match the input exactly, the decomposition is
| nevertheless valid and can be used to re-compose the original transformation.
|
| >>> T, R, N, S, K = transform.decompose(homogeneous=True)
| >>> T @ R @ N @ S @ K
| array([[-5.76153045e-17, -2.00000000e+00, 0.00000000e+00,
| 4.00000000e+00],
| [ 1.00000000e+00, 1.00000000e-01, 0.00000000e+00,
| 5.00000000e+00],
| [ 0.00000000e+00, 0.00000000e+00, 3.00000000e+00,
| 6.00000000e+00],
| [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
| 1.00000000e+00]])
|
| Alternatively, re-compose the transformation as a new
| :class:`~pyvista.Transform` with pre-multiplication.
|
| >>> recomposed = pv.Transform([T, R, N, S, K], multiply_mode='pre')
| >>> np.allclose(recomposed.matrix, transform.matrix)
| True
|
| Compose a reflection and decompose the transform again.
|
| >>> _ = transform.flip_x()
| >>> T, R, N, S, K = transform.decompose()
|
| The reflection component is now ``-1``.
|
| >>> N # reflection
| array(-1.)
|
| The decomposition may be simplified to a ``TRSK`` decomposition by combining
| the reflection component with either the rotation or the scaling term.
|
| Multiplying the reflection with the rotation will make it a left-handed rotation
| with negative determinant:
|
| >>> R = R * N
| >>> np.linalg.det(R) < 0
| np.True_
|
| Alternatively, keep the rotation right-handed but make the scaling factors negative:
|
| >>> S = S * N
| >>> S # scale
| array([-0.99944491, -2.0022213 , -3. ])
|
| flip_x(self: 'Transform', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a reflection about the x-axis.
|
| Create a reflection about the x-axis and :meth:`compose` it
| with the current transformation :attr:`matrix` according to pre-multiply or
| post-multiply semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to reflect about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the reflection
| - :meth:`translate` away from ``point`` after the reflection
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| reflect, flip_y, flip_z
| Similar reflection methods.
|
| pyvista.DataObjectFilters.flip_x
| Flip a mesh about the x-axis.
|
| reflection, has_reflection
| Get info about the transform's reflection component.
|
| Examples
| --------
| Compose a reflection about the x-axis.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform()
| >>> _ = transform.flip_x()
| >>> transform.matrix
| array([[-1., 0., 0., 0.],
| [ 0., 1., 0., 0.],
| [ 0., 0., 1., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second reflection, but this time about a point.
|
| >>> _ = transform.flip_x(point=(4, 5, 6))
| >>> transform.matrix
| array([[1., 0., 0., 8.],
| [0., 1., 0., 0.],
| [0., 0., 1., 0.],
| [0., 0., 0., 1.]])
|
| flip_y(self: 'Transform', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a reflection about the y-axis.
|
| Create a reflection about the y-axis and :meth:`compose` it
| with the current transformation :attr:`matrix` according to pre-multiply or
| post-multiply semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to reflect about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the reflection
| - :meth:`translate` away from ``point`` after the reflection
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| reflect, flip_x, flip_z
| Similar reflection methods.
|
| pyvista.DataObjectFilters.flip_y
| Flip a mesh about the y-axis.
|
| reflection, has_reflection
| Get info about the transform's reflection component.
|
| Examples
| --------
| Compose a reflection about the y-axis.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform()
| >>> _ = transform.flip_y()
| >>> transform.matrix
| array([[ 1., 0., 0., 0.],
| [ 0., -1., 0., 0.],
| [ 0., 0., 1., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second reflection, but this time about a point.
|
| >>> _ = transform.flip_y(point=(4, 5, 6))
| >>> transform.matrix
| array([[ 1., 0., 0., 0.],
| [ 0., 1., 0., 10.],
| [ 0., 0., 1., 0.],
| [ 0., 0., 0., 1.]])
|
| flip_z(self: 'Transform', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a reflection about the z-axis.
|
| Create a reflection about the z-axis and :meth:`compose` it
| with the current transformation :attr:`matrix` according to pre-multiply or
| post-multiply semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| point : VectorLike[float], optional
| Point to reflect about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the reflection
| - :meth:`translate` away from ``point`` after the reflection
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| reflect, flip_x, flip_y
| Similar reflection methods.
|
| pyvista.DataObjectFilters.flip_z
| Flip a mesh about the z-axis.
|
| reflection, has_reflection
| Get info about the transform's reflection component.
|
| Examples
| --------
| Compose a reflection about the z-axis.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform()
| >>> _ = transform.flip_z()
| >>> transform.matrix
| array([[ 1., 0., 0., 0.],
| [ 0., 1., 0., 0.],
| [ 0., 0., -1., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second reflection, but this time about a point.
|
| >>> _ = transform.flip_z(point=(4, 5, 6))
| >>> transform.matrix
| array([[ 1., 0., 0., 0.],
| [ 0., 1., 0., 0.],
| [ 0., 0., 1., 12.],
| [ 0., 0., 0., 1.]])
|
| identity(self: 'Transform') -> 'Transform'
| Set the transformation to the identity transformation.
|
| This can be used to "reset" the transform.
|
| Examples
| --------
| Compose an arbitrary transformation.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().scale(2.0)
| >>> transform.matrix
| array([[2., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 2., 0.],
| [0., 0., 0., 1.]])
|
| Reset the transformation to the identity matrix.
|
| >>> _ = transform.identity()
| >>> transform.matrix
| array([[1., 0., 0., 0.],
| [0., 1., 0., 0.],
| [0., 0., 1., 0.],
| [0., 0., 0., 1.]])
|
| invert(self: 'Transform') -> 'Transform'
| Invert the current transformation.
|
| The current transformation :attr:`matrix` (including all matrices in the
| :attr:`matrix_list`) is inverted every time :meth:`invert` is called.
|
| Use :attr:`is_inverted` to check if the transformations are currently inverted.
|
| Examples
| --------
| Compose an arbitrary transformation.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().scale(2.0)
| >>> transform.matrix
| array([[2., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 2., 0.],
| [0., 0., 0., 1.]])
|
| Check if the transformation is inverted.
|
| >>> transform.is_inverted
| False
|
| Invert the transformation and show the matrix.
|
| >>> _ = transform.invert()
| >>> transform.matrix
| array([[0.5, 0. , 0. , 0. ],
| [0. , 0.5, 0. , 0. ],
| [0. , 0. , 0.5, 0. ],
| [0. , 0. , 0. , 1. ]])
|
| Check that the transformation is inverted.
|
| >>> transform.is_inverted
| True
|
| Invert it again to restore it back to its original state.
|
| >>> _ = transform.invert()
| >>> transform.matrix
| array([[2., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 2., 0.],
| [0., 0., 0., 1.]])
| >>> transform.is_inverted
| False
|
| post_multiply(self: 'Transform') -> 'Transform'
| Set the multiplication mode to post-multiply.
|
| In post-multiply mode, any additional transformations (e.g. using
| :meth:`translate`, :meth:`compose`, etc.) will occur *after* any
| transformations represented by the current :attr:`matrix`.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> transform = pv.Transform().post_multiply()
| >>> transform.multiply_mode
| 'post'
|
| pre_multiply(self: 'Transform') -> 'Transform'
| Set the multiplication mode to pre-multiply.
|
| In pre-multiply mode, any additional transformations (e.g. using
| :meth:`translate`, :meth:`compose`, etc.) will occur *before* any
| transformations represented by the current :attr:`matrix`.
|
| Examples
| --------
| >>> import pyvista as pv
| >>> transform = pv.Transform().pre_multiply()
| >>> transform.multiply_mode
| 'pre'
|
| reflect(self: 'Transform', *normal: 'float | VectorLike[float]', point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a reflection matrix.
|
| Create a reflection matrix and :meth:`compose` it with the current
| transformation :attr:`matrix` according to pre-multiply or post-multiply
| semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| *normal : float | VectorLike[float]
| Normal direction for reflection. May be a single vector (one arg) or
| unpacked vector (three args).
|
| point : VectorLike[float], optional
| Point to reflect about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the reflection
| - :meth:`translate` away from ``point`` after the reflection
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| flip_x, flip_y, flip_z
| Convenience methods for reflecting about the x-, y-, or z-axis.
|
| pyvista.DataObjectFilters.reflect
| Reflect a mesh.
|
| reflection, has_reflection
| Get info about the transform's reflection component.
|
| Examples
| --------
| Compose a reflection matrix.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform()
| >>> _ = transform.reflect(0, 0, 1)
| >>> transform.matrix
| array([[ 1., 0., 0., 0.],
| [ 0., 1., 0., 0.],
| [ 0., 0., -1., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second reflection matrix.
|
| >>> _ = transform.reflect((1, 0, 0))
| >>> transform.matrix
| array([[-1., 0., 0., 0.],
| [ 0., 1., 0., 0.],
| [ 0., 0., -1., 0.],
| [ 0., 0., 0., 1.]])
|
| rotate(self: 'Transform', rotation: 'RotationLike', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a rotation matrix.
|
| Create a rotation matrix and :meth:`compose` it with the current
| transformation :attr:`matrix` according to pre-multiply or post-multiply
| semantics. The rotation may be right-handed or left-handed.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| rotation : RotationLike
| 3x3 rotation matrix or a SciPy ``Rotation`` object.
|
| point : VectorLike[float], optional
| Point to rotate about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the rotation
| - :meth:`translate` away from ``point`` after the rotation
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| rotate_x, rotate_y, rotate_z, rotate_vector
| Similar rotation methods.
| rotation_matrix, rotation_axis_angle, as_rotation, has_rotation
| Get this transform's rotation component.
| pyvista.DataObjectFilters.rotate
| Rotate a mesh.
|
| Examples
| --------
| Compose a rotation matrix. In this case the rotation rotates about the
| z-axis by 90 degrees.
|
| >>> import pyvista as pv
| >>> rotation_z_90 = [[0, -1, 0], [1, 0, 0], [0, 0, 1]]
| >>> transform = pv.Transform().rotate(rotation_z_90)
| >>> transform.matrix
| array([[ 0., -1., 0., 0.],
| [ 1., 0., 0., 0.],
| [ 0., 0., 1., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second rotation matrix. In this case we use the same rotation as
| before.
|
| >>> _ = transform.rotate(rotation_z_90)
|
| The result is a matrix that rotates about the z-axis by 180 degrees.
|
| >>> transform.matrix
| array([[-1., 0., 0., 0.],
| [ 0., -1., 0., 0.],
| [ 0., 0., 1., 0.],
| [ 0., 0., 0., 1.]])
|
| Rotate about a point. Check the :attr:`matrix_list` to see that a translation
| is added before and after the rotation.
|
| >>> transform = pv.Transform().rotate(rotation_z_90, point=(1, 2, 3))
| >>> translation_to_origin = transform.matrix_list[0]
| >>> translation_to_origin
| array([[ 1., 0., 0., -1.],
| [ 0., 1., 0., -2.],
| [ 0., 0., 1., -3.],
| [ 0., 0., 0., 1.]])
|
| >>> rotation = transform.matrix_list[1]
| >>> rotation
| array([[ 0., -1., 0., 0.],
| [ 1., 0., 0., 0.],
| [ 0., 0., 1., 0.],
| [ 0., 0., 0., 1.]])
|
| >>> translation_from_origin = transform.matrix_list[2]
| >>> translation_from_origin
| array([[1., 0., 0., 1.],
| [0., 1., 0., 2.],
| [0., 0., 1., 3.],
| [0., 0., 0., 1.]])
|
| rotate_vector(self: 'Transform', vector: 'VectorLike[float]', angle: 'float', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a rotation about a vector.
|
| Create a matrix for rotation about the vector and :meth:`compose`
| it with the current transformation :attr:`matrix` according to pre-multiply or
| post-multiply semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| vector : VectorLike[float]
| Vector to rotate about.
|
| angle : float
| Angle in degrees to rotate about the vector.
|
| point : VectorLike[float], optional
| Point to rotate about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the rotation
| - :meth:`translate` away from ``point`` after the rotation
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| rotate_x, rotate_y, rotate_z, rotate
| Similar rotation methods.
| rotation_matrix, rotation_axis_angle, as_rotation, has_rotation
| Get this transform's rotation component.
| pyvista.DataObjectFilters.rotate_vector
| Rotate a mesh about a vector.
|
| Examples
| --------
| Compose a rotation of 30 degrees about the ``(1, 1, 1)`` axis.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().rotate_vector((1, 1, 1), 30)
| >>> transform.matrix
| array([[ 0.9106836 , -0.24401694, 0.33333333, 0. ],
| [ 0.33333333, 0.9106836 , -0.24401694, 0. ],
| [-0.24401694, 0.33333333, 0.9106836 , 0. ],
| [ 0. , 0. , 0. , 1. ]])
|
| Compose a second rotation of 45 degrees about the ``(1, 2, 3)`` axis.
|
| >>> _ = transform.rotate_vector((1, 2, 3), 45)
| >>> transform.matrix
| array([[ 0.38042304, -0.50894634, 0.77217351, 0. ],
| [ 0.83349512, 0.55045308, -0.04782562, 0. ],
| [-0.40070461, 0.66179682, 0.63360933, 0. ],
| [ 0. , 0. , 0. , 1. ]])
|
| rotate_x(self: 'Transform', angle: 'float', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a rotation about the x-axis.
|
| Create a matrix for rotation about the x-axis and :meth:`compose`
| it with the current transformation :attr:`matrix` according to pre-multiply or
| post-multiply semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the x-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the rotation
| - :meth:`translate` away from ``point`` after the rotation
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| rotate_y, rotate_z, rotate_vector, rotate
| Similar rotation methods.
| rotation_matrix, rotation_axis_angle, as_rotation, has_rotation
| Get this transform's rotation component.
| pyvista.DataObjectFilters.rotate_x
| Rotate a mesh about the x-axis.
|
| Examples
| --------
| Compose a rotation about the x-axis.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().rotate_x(90)
| >>> transform.matrix
| array([[ 1., 0., 0., 0.],
| [ 0., 0., -1., 0.],
| [ 0., 1., 0., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second rotation about the x-axis.
|
| >>> _ = transform.rotate_x(45)
|
| The result is a matrix that rotates about the x-axis by 135 degrees.
|
| >>> transform.matrix
| array([[ 1. , 0. , 0. , 0. ],
| [ 0. , -0.70710678, -0.70710678, 0. ],
| [ 0. , 0.70710678, -0.70710678, 0. ],
| [ 0. , 0. , 0. , 1. ]])
|
| rotate_y(self: 'Transform', angle: 'float', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a rotation about the y-axis.
|
| Create a matrix for rotation about the y-axis and :meth:`compose`
| it with the current transformation :attr:`matrix` according to pre-multiply or
| post-multiply semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the y-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the rotation
| - :meth:`translate` away from ``point`` after the rotation
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| rotate_x, rotate_z, rotate_vector, rotate
| Similar rotation methods.
| rotation_matrix, rotation_axis_angle, as_rotation, has_rotation
| Get this transform's rotation component.
| pyvista.DataObjectFilters.rotate_y
| Rotate a mesh about the y-axis.
|
| Examples
| --------
| Compose a rotation about the y-axis.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().rotate_y(90)
| >>> transform.matrix
| array([[ 0., 0., 1., 0.],
| [ 0., 1., 0., 0.],
| [-1., 0., 0., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second rotation about the y-axis.
|
| >>> _ = transform.rotate_y(45)
|
| The result is a matrix that rotates about the y-axis by 135 degrees.
|
| >>> transform.matrix
| array([[-0.70710678, 0. , 0.70710678, 0. ],
| [ 0. , 1. , 0. , 0. ],
| [-0.70710678, 0. , -0.70710678, 0. ],
| [ 0. , 0. , 0. , 1. ]])
|
| rotate_z(self: 'Transform', angle: 'float', *, point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a rotation about the z-axis.
|
| Create a matrix for rotation about the z-axis and :meth:`compose`
| it with the current transformation :attr:`matrix` according to pre-multiply or
| post-multiply semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| angle : float
| Angle in degrees to rotate about the z-axis.
|
| point : VectorLike[float], optional
| Point to rotate about. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the rotation
| - :meth:`translate` away from ``point`` after the rotation
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| rotate_x, rotate_y, rotate_vector, rotate
| Similar rotation methods.
| rotation_matrix, rotation_axis_angle, as_rotation, has_rotation
| Get this transform's rotation component.
| pyvista.DataObjectFilters.rotate_z
| Rotate a mesh about the z-axis.
|
| Examples
| --------
| Compose a rotation about the z-axis.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().rotate_z(90)
| >>> transform.matrix
| array([[ 0., -1., 0., 0.],
| [ 1., 0., 0., 0.],
| [ 0., 0., 1., 0.],
| [ 0., 0., 0., 1.]])
|
| Compose a second rotation about the z-axis.
|
| >>> _ = transform.rotate_z(45)
|
| The result is a matrix that rotates about the z-axis by 135 degrees.
|
| >>> transform.matrix
| array([[-0.70710678, -0.70710678, 0. , 0. ],
| [ 0.70710678, -0.70710678, 0. , 0. ],
| [ 0. , 0. , 1. , 0. ],
| [ 0. , 0. , 0. , 1. ]])
|
| scale(self: 'Transform', *factor: 'float | VectorLike[float]', point: 'VectorLike[float] | None' = None, multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a scale matrix.
|
| Create a scale matrix and :meth:`compose` it with the current
| transformation :attr:`matrix` according to pre-multiply or post-multiply
| semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| *factor : float | VectorLike[float]
| Scale factor(s) to use. Use a single number for uniform scaling or
| three numbers for non-uniform scaling. The three factors may be
| passed as a single vector (one arg) or an unpacked vector (three args).
|
| point : VectorLike[float], optional
| Point to scale from. By default, the object's :attr:`point` is used,
| but this can be overridden.
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the scaling
| - :meth:`translate` away from ``point`` after the scaling
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| pyvista.DataObjectFilters.scale
| Scale a mesh.
|
| pyvista.DataObjectFilters.resize
| Resize a mesh.
|
| scale_factors, has_scale
| Get info about the transform's scale component.
|
| Examples
| --------
| Compose a scale matrix.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().scale(1, 2, 3)
| >>> transform.matrix
| array([[1., 0., 0., 0.],
| [0., 2., 0., 0.],
| [0., 0., 3., 0.],
| [0., 0., 0., 1.]])
|
| Compose a second scale matrix using ``*``.
|
| >>> transform = transform * 2
| >>> transform.matrix
| array([[2., 0., 0., 0.],
| [0., 4., 0., 0.],
| [0., 0., 6., 0.],
| [0., 0., 0., 1.]])
|
| Scale from a point. Check the :attr:`matrix_list` to see that a translation
| is added before and after the scaling.
|
| >>> transform = pv.Transform().scale(7, point=(1, 2, 3))
| >>> translation_to_origin = transform.matrix_list[0]
| >>> translation_to_origin
| array([[ 1., 0., 0., -1.],
| [ 0., 1., 0., -2.],
| [ 0., 0., 1., -3.],
| [ 0., 0., 0., 1.]])
|
| >>> scale = transform.matrix_list[1]
| >>> scale
| array([[7., 0., 0., 0.],
| [0., 7., 0., 0.],
| [0., 0., 7., 0.],
| [0., 0., 0., 1.]])
|
| >>> translation_from_origin = transform.matrix_list[2]
| >>> translation_from_origin
| array([[1., 0., 0., 1.],
| [0., 1., 0., 2.],
| [0., 0., 1., 3.],
| [0., 0., 0., 1.]])
|
| translate(self: 'Transform', *vector: 'float | VectorLike[float]', multiply_mode: "Literal['pre', 'post'] | None" = None) -> 'Transform'
| Compose a translation matrix.
|
| Create a translation matrix and :meth:`compose` it with the current
| transformation :attr:`matrix` according to pre-multiply or post-multiply
| semantics.
|
| Internally, the matrix is stored in the :attr:`matrix_list`.
|
| Parameters
| ----------
| *vector : float | VectorLike[float]
| Vector to use for translation. May be a single vector (one arg) or
| unpacked vector (three args).
|
| multiply_mode : 'pre' | 'post', optional
| Multiplication mode to use when composing the matrix. By default, the
| object's :attr:`multiply_mode` is used, but this can be overridden. Set this
| to ``'pre'`` for pre-multiplication or ``'post'`` for post-multiplication.
|
| See Also
| --------
| pyvista.DataObjectFilters.translate
| Translate a mesh.
|
| translation, has_translation
| Get info about the transform's translation component.
|
| Examples
| --------
| Compose a translation matrix.
|
| >>> import pyvista as pv
| >>> transform = pv.Transform().translate(1, 2, 3)
| >>> transform.matrix
| array([[1., 0., 0., 1.],
| [0., 1., 0., 2.],
| [0., 0., 1., 3.],
| [0., 0., 0., 1.]])
|
| Compose a second translation matrix using ``+``.
|
| >>> transform = transform + (1, 1, 1)
| >>> transform.matrix
| array([[1., 0., 0., 2.],
| [0., 1., 0., 3.],
| [0., 0., 1., 4.],
| [0., 0., 0., 1.]])
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| has_reflection
| Return ``True`` if the current transformation :attr:`~Transform.matrix` has a reflection component.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| reflection, reflect, decompose
|
| has_rotation
| Return ``True`` if the current transformation :attr:`~Transform.matrix` has a rotation component.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| rotation_matrix, rotate, decompose
|
| has_scale
| Return ``True`` if the current transformation :attr:`~Transform.matrix` has a scale component.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| scale_factors, scale, decompose
|
| has_shear
| Return ``True`` if the current transformation :attr:`~Transform.matrix` has a shear component.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| shear_matrix, compose, decompose
|
| has_translation
| Return ``True`` if the current transformation :attr:`~Transform.matrix` has a translation component.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| translation, translate, decompose
|
| inverse_matrix
| Return the inverse of the current transformation :attr:`~Transform.matrix`.
|
| Notes
| -----
| This matrix is a single 4x4 matrix computed from composing the inverse of
| all transformations. Use :attr:`inverse_matrix_list` instead to get a list of
| the individual inverse transformations.
|
| See Also
| --------
| matrix
| Return the current transformation matrix.
|
| Returns
| -------
| NDArray[float]
| Current inverse transformation matrix.
|
| inverse_matrix_list
| Return a list of all inverse transformations applied by this :class:`Transform`.
|
| Notes
| -----
| The list comprises all 4x4 inverse transformation matrices. Use
| :attr:`inverse_matrix` instead to get the composed result as a single
| 4x4 matrix.
|
| See Also
| --------
| matrix_list
| Return a list of all transformation matrices.
|
| Returns
| -------
| list[NDArray[float]]
| List of all current inverse transformation matrices.
|
| is_inverted
| Get the inverse flag of the transformation.
|
| This flag is modified whenever :meth:`invert` is called.
|
| matrix_list
| Return a list of all current transformation matrices.
|
| Notes
| -----
| The list comprises all 4x4 transformation matrices. Use :attr:`matrix` instead
| to get the composed result as a single 4x4 matrix.
|
| See Also
| --------
| inverse_matrix_list
| Return the current transformation matrix.
|
| Returns
| -------
| list[NDArray[float]]
| List of all current transformation matrices.
|
| n_transformations
| Return the current number of composed transformations.
|
| reflection
| Return the reflection component of the current transformation :attr:`~Transform.matrix` as an integer.
|
| ``1`` is returned if there is no reflection, and ``-1`` is returned if there
| is a reflection.
|
| See Also
| --------
| has_reflection, reflect, decompose
|
| Examples
| --------
| Create a transform and get its reflection.
|
| >>> import pyvista as pv
| >>> trans = pv.Transform()
| >>> trans.reflection
| 1
|
| Compose a reflection about the x-axis and get the reflection again.
|
| >>> _ = trans.flip_x()
| >>> trans.reflection
| -1
|
| Compose a second reflection and get the reflection again.
|
| >>> _ = trans.flip_y()
| >>> trans.reflection
| 1
|
| rotation_axis_angle
| Return the rotation component of the current transformation :attr:`~Transform.matrix` as a vector and angle.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| has_rotation, rotation_matrix, rotate_vector, as_rotation, decompose
|
| Examples
| --------
| Compose a rotation from a vector and angle.
|
| >>> import pyvista as pv
| >>> trans = pv.Transform().rotate_vector((1, 2, 3), 30)
|
| Get the rotation axis and angle.
|
| >>> axis, angle = trans.rotation_axis_angle
| >>> axis
| (0.2672, 0.5345, 0.8017)
| >>> angle
| 30.0
|
| Compose a second rotation around the same axis and get the axis and angle again.
|
| >>> _ = trans.rotate_vector((1, 2, 3), 40)
| >>> axis, angle = trans.rotation_axis_angle
| >>> axis
| (0.2672, 0.5345, 0.8017)
| >>> angle
| 70.0
|
| rotation_matrix
| Return the rotation component of the current transformation :attr:`~Transform.matrix` as a 3x3 matrix.
|
| The rotation is orthonormal and right-handed with positive determinant.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| has_rotation, rotation_axis_angle, rotate, as_rotation, decompose
|
| Examples
| --------
| Compose a rotation about the z-axis.
|
| >>> import pyvista as pv
| >>> trans = pv.Transform().rotate_z(90)
|
| Get the rotation matrix.
|
| >>> trans.rotation_matrix
| array([[ 0., -1., 0.],
| [ 1., 0., 0.],
| [ 0., 0., 1.]])
|
| Compose a second rotation and get the rotation matrix again.
|
| >>> _ = trans.rotate_y(-90)
| >>> trans.rotation_matrix
| array([[ 0., 0., -1.],
| [ 1., 0., 0.],
| [ 0., -1., 0.]])
|
| scale_factors
| Return the scaling component of the current transformation :attr:`~Transform.matrix`.
|
| The scaling factors are always positive.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| has_scale, scale, decompose
|
| Examples
| --------
| Compose a scale matrix and get the scale factors.
|
| >>> import pyvista as pv
| >>> trans = pv.Transform() * (1, 2, 3)
| >>> trans.scale_factors
| (1.0, 2.0, 3.0)
|
| Compose a second scale matrix and get the factors again.
|
| >>> trans *= (4, 5, 6)
| >>> trans.scale_factors
| (4.0, 10.0, 18.0)
|
| shear_matrix
| Return the shear component of the current transformation :attr:`~Transform.matrix` as a 3x3 matrix.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| has_shear, compose, decompose
|
| Examples
| --------
| Compose a symmetric shear matrix.
|
| >>> import numpy as np
| >>> import pyvista as pv
| >>> shear = np.eye(4)
| >>> shear[0, 1] = 0.1
| >>> shear[1, 0] = 0.1
| >>> trans = pv.Transform(shear)
|
| Get the shear matrix. The shear matrix is the same as the input in this particular example,
| but in general this is not the case.
|
| >>> trans.shear_matrix
| array([[1. , 0.1, 0. ],
| [0.1, 1. , 0. ],
| [0. , 0. , 1. ]])
|
| Compose an asymmetric shear matrix instead.
|
| >>> shear = np.eye(4)
| >>> shear[0, 1] = 0.1
| >>> trans = pv.Transform(shear)
|
| Get the shear matrix. In this case, shear differs from the input because asymmetric shear
| can be decomposed into scale factors and a rotation.
|
| >>> trans.shear_matrix
| array([[1. , 0.05 , 0. ],
| [0.04975124, 1. , 0. ],
| [0. , 0. , 1. ]])
|
| >>> trans.scale_factors
| (0.9987523388778445, 1.0037461005722337, 1.0)
|
| >>> axis, angle = trans.rotation_axis_angle
| >>> axis
| (0.0, 0.0, -1.0)
| >>> angle
| 2.8624
|
| translation
| Return the translation component of the current transformation :attr:`~Transform.matrix`.
|
| .. versionadded:: 0.47
|
| See Also
| --------
| has_translation, translate, decompose
|
| Examples
| --------
| Compose a translation and get the translation component.
|
| >>> import pyvista as pv
| >>> trans = pv.Transform() + (1, 2, 3)
| >>> trans.translation
| (1.0, 2.0, 3.0)
|
| Compose a second translation and get the component again.
|
| >>> trans += (4, 5, 6)
| >>> trans.translation
| (5.0, 7.0, 9.0)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| check_finite
| Check that the :attr:`~Transform.matrix` and :attr:`~Transform.inverse_matrix` have finite values.
|
| If ``True``, all transformations are checked to ensure they only contain
| finite values (i.e. no ``NaN`` or ``Inf`` values) and a ``ValueError`` is raised
| otherwise. This is useful to catch cases where the transformation(s) are poorly
| defined and/or are numerically unstable.
|
| This flag is enabled by default.
|
| matrix
| Return or set the current transformation matrix.
|
| Notes
| -----
| This matrix is a single 4x4 matrix computed from composing all
| transformations. Use :attr:`matrix_list` instead to get a list of the
| individual transformations.
|
| See Also
| --------
| inverse_matrix
| Return the inverse of the current transformation.
|
| Returns
| -------
| NDArray[float]
| Current transformation matrix.
|
| multiply_mode
| Set or get the multiplication mode.
|
| Set this to ``'pre'`` to set the multiplication mode to :meth:`pre_multiply`.
| Set this to ``'post'`` to set it to :meth:`post_multiply`.
|
| In pre-multiply mode, any additional transformations (e.g. using
| :meth:`translate`, :meth:`compose`, etc.) will occur *before* any
| transformations represented by the current :attr:`matrix`.
| In post-multiply mode, the additional transformation will occur *after* any
| transformations represented by the current matrix.
|
| point
| Point to use when composing some transformations such as scale, rotation, etc.
|
| If set, two additional transformations are composed and added to
| the :attr:`matrix_list`:
|
| - :meth:`translate` to ``point`` before the transformation
| - :meth:`translate` away from ``point`` after the transformation
|
| By default, this value is ``None``, which means that the scale, rotation, etc.
| transformations are performed about the origin ``(0, 0, 0)``.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __setattr__(self, key: 'str', value: 'Any') -> 'None'
| Prevent adding new attributes to classes using "normal" methods.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pyvista.core.utilities.misc._NoNewAttrMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| __dir__(self) -> 'list[str]'
| Return a filtered attribute listing for :func:`dir` and tab-completion.
|
| VTK-inherited names are hidden by default so PyVista objects present
| a curated public surface in data-science IDEs (Positron Variables
| pane, VS Code Jupyter extension, ...) and in IPython / Jupyter
| tab-completion. VTK methods remain fully callable; only their
| enumeration is suppressed.
|
| - CamelCase VTK attributes (``GetNumberOfPoints``, ``DeepCopy``, ...) are
| hidden unless :attr:`pyvista.global_config.show_vtk_api` is
| ``True``.
| - snake_case VTK aliases (``number_of_points``, ``deep_copy``, ...) are
| hidden unless VTK snake_case is allowed via
| :func:`pyvista.vtk_snake_case`, since they would otherwise raise
| ``PyVistaAttributeError`` on access.
|
| __getattribute__(self, item)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from pyvista.core._vtk_utilities.DisableVtkSnakeCase:
|
| check_attribute(target, attr)
|
| ----------------------------------------------------------------------
| Class methods inherited from pyvista.core._vtk_utilities.vtkPyVistaOverride:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonTransforms.vtkTransform:
|
| CircuitCheck(...)
| CircuitCheck(self, transform:vtkAbstractTransform) -> int
| C++: int CircuitCheck(vtkAbstractTransform *transform) override;
|
| Check for self-reference. Will return true if concatenating with
| the specified transform, setting it to be our inverse, or setting
| it to be our input will create a circular reference. CircuitCheck
| is automatically called by SetInput(), SetInverse(), and
| Concatenate(vtkXTransform *). Avoid using this function, it is
| experimental.
|
| Concatenate(...)
| Concatenate(self, matrix:vtkMatrix4x4) -> None
| C++: void Concatenate(vtkMatrix4x4 *matrix)
| Concatenate(self, elements:(float, float, float, float, float,
| float, float, float, float, float, float, float, float, float,
| float, float)) -> None
| C++: void Concatenate(const double elements[16])
| Concatenate(self, transform:vtkLinearTransform) -> None
| C++: void Concatenate(vtkLinearTransform *transform)
|
| Concatenates the matrix with the current transformation according
| to PreMultiply or PostMultiply semantics.
|
| GetConcatenatedTransform(...)
| GetConcatenatedTransform(self, i:int) -> vtkLinearTransform
| C++: vtkLinearTransform *GetConcatenatedTransform(int i)
|
| Get one of the concatenated transformations as a
| vtkAbstractTransform. These transformations are applied, in
| series, every time the transformation of a coordinate occurs.
| This method is provided to make it possible to decompose a
| transformation into its constituents, for example to save a
| transformation to a file.
|
| GetInput(...)
| GetInput(self) -> vtkLinearTransform
| C++: vtkLinearTransform *GetInput()
|
| GetInverse(...)
| GetInverse(self, inverse:vtkMatrix4x4) -> None
| C++: void GetInverse(vtkMatrix4x4 *inverse)
| GetInverse(self) -> vtkAbstractTransform
| C++: vtkAbstractTransform *GetInverse()
|
| Return a matrix which is the inverse of the current
| transformation matrix.
|
| GetInverseFlag(...)
| GetInverseFlag(self) -> int
| C++: vtkTypeBool GetInverseFlag()
|
| Get the inverse flag of the transformation. This controls
| whether it is the Input or the inverse of the Input that is used
| as the base transformation. The InverseFlag is flipped every
| time Inverse() is called. The InverseFlag is off when a
| transform is first created.
|
| GetMTime(...)
| GetMTime(self) -> int
| C++: vtkMTimeType GetMTime() override;
|
| Override GetMTime to account for input and concatenation.
|
| GetNumberOfConcatenatedTransforms(...)
| GetNumberOfConcatenatedTransforms(self) -> int
| C++: int GetNumberOfConcatenatedTransforms()
|
| Get the total number of transformations that are linked into this
| one via Concatenate() operations or via SetInput().
|
| GetNumberOfGenerationsFromBase(...)
| GetNumberOfGenerationsFromBase(self, type:str) -> int
| C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
| override;
|
| Given the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetNumberOfGenerationsFromBaseType(...)
| GetNumberOfGenerationsFromBaseType(type:str) -> int
| C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
| const char *type)
|
| Given a the name of a base class of this class type, return the
| distance of inheritance between this class type and the named
| class (how many generations of inheritance are there between this
| class and the named class). If the named class is not in this
| class's inheritance tree, return a negative value. Valid
| responses will always be nonnegative. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| GetOrientation(...)
| GetOrientation(self, orient:[float, float, float]) -> None
| C++: void GetOrientation(double orient[3])
| GetOrientation(self) -> (float, float, float)
| C++: double *GetOrientation()
| GetOrientation(orient:[float, float, float], matrix:vtkMatrix4x4)
| -> None
| C++: static void GetOrientation(double orient[3],
| vtkMatrix4x4 *matrix)
|
| Get the x, y, z orientation angles from the transformation matrix
| as an array of three floating point values.
|
| GetOrientationWXYZ(...)
| GetOrientationWXYZ(self, wxyz:[float, float, float, float])
| -> None
| C++: void GetOrientationWXYZ(double wxyz[4])
| GetOrientationWXYZ(self) -> (float, float, float, float)
| C++: double *GetOrientationWXYZ()
|
| Return the wxyz angle+axis representing the current orientation.
| The angle is in degrees and the axis is a unit vector.
|
| GetPosition(...)
| GetPosition(self, pos:[float, float, float]) -> None
| C++: void GetPosition(double pos[3])
| GetPosition(self) -> (float, float, float)
| C++: double *GetPosition()
|
| Return the position from the current transformation matrix as an
| array of three floating point numbers. This is simply returning
| the translation component of the 4x4 matrix.
|
| GetScale(...)
| GetScale(self, scale:[float, float, float]) -> None
| C++: void GetScale(double scale[3])
| GetScale(self) -> (float, float, float)
| C++: double *GetScale()
|
| Return the scale factors of the current transformation matrix as
| an array of three float numbers. These scale factors are not
| necessarily about the x, y, and z axes unless unless the scale
| transformation was applied before any rotations.
|
| GetTranspose(...)
| GetTranspose(self, transpose:vtkMatrix4x4) -> None
| C++: void GetTranspose(vtkMatrix4x4 *transpose)
|
| Return a matrix which is the transpose of the current
| transformation matrix. This is equivalent to the inverse if and
| only if the transformation is a pure rotation with no translation
| or scale.
|
| Identity(...)
| Identity(self) -> None
| C++: void Identity()
|
| Set the transformation to the identity transformation. If the
| transform has an Input, then the transformation will be reset so
| that it is the same as the Input.
|
| Inverse(...)
| Inverse(self) -> None
| C++: void Inverse() override;
|
| Invert the transformation. This will also set a flag so that the
| transformation will use the inverse of its Input, if an Input has
| been set.
|
| IsA(...)
| IsA(self, type:str) -> int
| C++: vtkTypeBool IsA(const char *type) override;
|
| Return 1 if this class is the same type of (or a subclass of) the
| named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| IsTypeOf(...)
| IsTypeOf(type:str) -> int
| C++: static vtkTypeBool IsTypeOf(const char *type)
|
| Return 1 if this class type is the same type of (or a subclass
| of) the named class. Returns 0 otherwise. This method works in
| combination with vtkTypeMacro found in vtkSetGet.h.
|
| MakeTransform(...)
| MakeTransform(self) -> vtkAbstractTransform
| C++: vtkAbstractTransform *MakeTransform() override;
|
| Make a new transform of the same type.
|
| MultiplyPoint(...)
| MultiplyPoint(self, in_:(float, float, float, float), out:[float,
| float, float, float]) -> None
| C++: void MultiplyPoint(const double in[4], double out[4])
|
| NewInstance(...)
| NewInstance(self) -> vtkTransform
| C++: vtkTransform *NewInstance()
|
| Pop(...)
| Pop(self) -> None
| C++: void Pop()
|
| Deletes the transformation on the top of the stack and sets the
| top to the next transformation on the stack.
|
| PostMultiply(...)
| PostMultiply(self) -> None
| C++: void PostMultiply()
|
| Sets the internal state of the transform to PostMultiply. All
| subsequent operations will occur after those already represented
| in the current transformation. In homogeneous matrix notation, M
| = A*M where M is the current transformation matrix and A is the
| applied matrix. The default is PreMultiply.
|
| PreMultiply(...)
| PreMultiply(self) -> None
| C++: void PreMultiply()
|
| Sets the internal state of the transform to PreMultiply. All
| subsequent operations will occur before those already represented
| in the current transformation. In homogeneous matrix notation, M
| = M*A where M is the current transformation matrix and A is the
| applied matrix. The default is PreMultiply.
|
| Push(...)
| Push(self) -> None
| C++: void Push()
|
| Pushes the current transformation onto the transformation stack.
|
| RotateWXYZ(...)
| RotateWXYZ(self, angle:float, x:float, y:float, z:float) -> None
| C++: void RotateWXYZ(double angle, double x, double y, double z)
| RotateWXYZ(self, angle:float, axis:(float, float, float)) -> None
| C++: void RotateWXYZ(double angle, const double axis[3])
|
| Create a rotation matrix and concatenate it with the current
| transformation according to PreMultiply or PostMultiply
| semantics. The angle is in degrees, and (x,y,z) specifies the
| axis that the rotation will be performed around.
|
| RotateX(...)
| RotateX(self, angle:float) -> None
| C++: void RotateX(double angle)
|
| Create a rotation matrix about the X, Y, or Z axis and
| concatenate it with the current transformation according to
| PreMultiply or PostMultiply semantics. The angle is expressed in
| degrees.
|
| RotateY(...)
| RotateY(self, angle:float) -> None
| C++: void RotateY(double angle)
|
| RotateZ(...)
| RotateZ(self, angle:float) -> None
| C++: void RotateZ(double angle)
|
| SafeDownCast(...)
| SafeDownCast(o:vtkObjectBase) -> vtkTransform
| C++: static vtkTransform *SafeDownCast(vtkObjectBase *o)
|
| Scale(...)
| Scale(self, x:float, y:float, z:float) -> None
| C++: void Scale(double x, double y, double z)
| Scale(self, s:(float, float, float)) -> None
| C++: void Scale(const double s[3])
|
| Create a scale matrix (i.e. set the diagonal elements to x, y, z)
| and concatenate it with the current transformation according to
| PreMultiply or PostMultiply semantics.
|
| SetInput(...)
| SetInput(self, input:vtkLinearTransform) -> None
| C++: void SetInput(vtkLinearTransform *input)
|
| Set the input for this transformation. This will be used as the
| base transformation if it is set. This method allows you to
| build a transform pipeline: if the input is modified, then this
| transformation will automatically update accordingly. Note that
| the InverseFlag, controlled via Inverse(), determines whether
| this transformation will use the Input or the inverse of the
| Input.
|
| SetMatrix(...)
| SetMatrix(self, matrix:vtkMatrix4x4) -> None
| C++: void SetMatrix(vtkMatrix4x4 *matrix)
| SetMatrix(self, elements:(float, float, float, float, float,
| float, float, float, float, float, float, float, float, float,
| float, float)) -> None
| C++: void SetMatrix(const double elements[16])
|
| Set the current matrix directly. Note: First, the current matrix
| is set to the identity, then the input matrix is concatenated.
|
| Translate(...)
| Translate(self, x:float, y:float, z:float) -> None
| C++: void Translate(double x, double y, double z)
| Translate(self, x:(float, float, float)) -> None
| C++: void Translate(const double x[3])
|
| Create a translation matrix and concatenate it with the current
| transformation according to PreMultiply or PostMultiply
| semantics.
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __release_buffer__(self, buffer, /)
| Release the buffer object that exposes the underlying memory of the object.
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from vtkmodules.vtkCommonTransforms.vtkTransform:
|
| __new__(*args, **kwargs) class method of vtkmodules.vtkCommonTransforms.vtkTransform
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonTransforms.vtkTransform:
|
| __this__
| Pointer to the C++ object.
|
| input
| read-write, calls GetInput/SetInput
|
| inverse
| read-only, calls GetInverse
|
| inverse_flag
| read-only, calls GetInverseFlag
|
| m_time
| read-only, calls GetMTime
|
| number_of_concatenated_transforms
| read-only, calls GetNumberOfConcatenatedTransforms
|
| orientation
| read-only, calls GetOrientation
|
| orientation_wxyz
| read-only, calls GetOrientationWXYZ
|
| position
| read-only, calls GetPosition
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from vtkmodules.vtkCommonTransforms.vtkTransform:
|
| __vtkname__ = 'vtkTransform'
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonTransforms.vtkLinearTransform:
|
| GetLinearInverse(...)
| GetLinearInverse(self) -> vtkLinearTransform
| C++: vtkLinearTransform *GetLinearInverse()
|
| Just like GetInverse, but it includes a typecast to
| vtkLinearTransform.
|
| InternalTransformDerivative(...)
| InternalTransformDerivative(self, in_:(float, float, float),
| out:[float, float, float], derivative:[[float, float, float],
| [float, float, float], [float, float, float]]) -> None
| C++: void InternalTransformDerivative(const double in[3],
| double out[3], double derivative[3][3]) override;
|
| InternalTransformNormal(...)
| InternalTransformNormal(self, in_:(float, float, float),
| out:[float, float, float]) -> None
| C++: virtual void InternalTransformNormal(const double in[3],
| double out[3])
|
| InternalTransformPoint(...)
| InternalTransformPoint(self, in_:(float, float, float),
| out:[float, float, float]) -> None
| C++: void InternalTransformPoint(const double in[3],
| double out[3]) override;
|
| InternalTransformVector(...)
| InternalTransformVector(self, in_:(float, float, float),
| out:[float, float, float]) -> None
| C++: virtual void InternalTransformVector(const double in[3],
| double out[3])
|
| TransformDoubleNormal(...)
| TransformDoubleNormal(self, x:float, y:float, z:float) -> (float,
| float, float)
| C++: double *TransformDoubleNormal(double x, double y, double z)
| TransformDoubleNormal(self, normal:(float, float, float)) -> (
| float, float, float)
| C++: double *TransformDoubleNormal(const double normal[3])
|
| Apply the transformation to a double-precision (x,y,z) normal.
| Use this if you are programming in python or Java.
|
| TransformDoubleVector(...)
| TransformDoubleVector(self, x:float, y:float, z:float) -> (float,
| float, float)
| C++: double *TransformDoubleVector(double x, double y, double z)
| TransformDoubleVector(self, vec:(float, float, float)) -> (float,
| float, float)
| C++: double *TransformDoubleVector(const double vec[3])
|
| Apply the transformation to a double-precision (x,y,z) vector.
| Use this if you are programming in python or Java.
|
| TransformFloatNormal(...)
| TransformFloatNormal(self, x:float, y:float, z:float) -> (float,
| float, float)
| C++: float *TransformFloatNormal(float x, float y, float z)
| TransformFloatNormal(self, normal:(float, float, float)) -> (
| float, float, float)
| C++: float *TransformFloatNormal(const float normal[3])
|
| Apply the transformation to an (x,y,z) normal. Use this if you
| are programming in python or Java.
|
| TransformFloatVector(...)
| TransformFloatVector(self, x:float, y:float, z:float) -> (float,
| float, float)
| C++: float *TransformFloatVector(float x, float y, float z)
| TransformFloatVector(self, vec:(float, float, float)) -> (float,
| float, float)
| C++: float *TransformFloatVector(const float vec[3])
|
| Apply the transformation to an (x,y,z) vector. Use this if you
| are programming in python or Java.
|
| TransformNormal(...)
| TransformNormal(self, in_:(float, float, float), out:[float,
| float, float]) -> None
| C++: void TransformNormal(const double in[3], double out[3])
| TransformNormal(self, x:float, y:float, z:float) -> (float, float,
| float)
| C++: double *TransformNormal(double x, double y, double z)
| TransformNormal(self, normal:(float, float, float)) -> (float,
| float, float)
| C++: double *TransformNormal(const double normal[3])
|
| Apply the transformation to a double-precision normal. You can
| use the same array to store both the input and output.
|
| TransformNormals(...)
| TransformNormals(self, inNms:vtkDataArray, outNms:vtkDataArray)
| -> None
| C++: virtual void TransformNormals(vtkDataArray *inNms,
| vtkDataArray *outNms)
|
| Apply the transformation to a series of normals, and append the
| results to outNms.
|
| TransformPoints(...)
| TransformPoints(self, inPts:vtkPoints, outPts:vtkPoints) -> None
| C++: void TransformPoints(vtkPoints *inPts, vtkPoints *outPts)
| override;
|
| Apply the transformation to a series of points, and append the
| results to outPts.
|
| TransformVector(...)
| TransformVector(self, x:float, y:float, z:float) -> (float, float,
| float)
| C++: double *TransformVector(double x, double y, double z)
| TransformVector(self, normal:(float, float, float)) -> (float,
| float, float)
| C++: double *TransformVector(const double normal[3])
| TransformVector(self, in_:(float, float, float), out:[float,
| float, float]) -> None
| C++: void TransformVector(const double in[3], double out[3])
|
| Synonymous with TransformDoubleVector(x,y,z). Use this if you are
| programming in python or Java.
|
| TransformVectors(...)
| TransformVectors(self, inVrs:vtkDataArray, outVrs:vtkDataArray)
| -> None
| C++: virtual void TransformVectors(vtkDataArray *inVrs,
| vtkDataArray *outVrs)
|
| Apply the transformation to a series of vectors, and append the
| results to outVrs.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonTransforms.vtkLinearTransform:
|
| linear_inverse
| read-only, calls GetLinearInverse
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonTransforms.vtkHomogeneousTransform:
|
| GetHomogeneousInverse(...)
| GetHomogeneousInverse(self) -> vtkHomogeneousTransform
| C++: vtkHomogeneousTransform *GetHomogeneousInverse()
|
| Just like GetInverse(), but includes typecast to
| vtkHomogeneousTransform.
|
| GetMatrix(...)
| GetMatrix(self, m:vtkMatrix4x4) -> None
| C++: void GetMatrix(vtkMatrix4x4 *m)
| GetMatrix(self) -> vtkMatrix4x4
| C++: vtkMatrix4x4 *GetMatrix()
|
| Get a copy of the internal transformation matrix. The transform
| is Updated first, to guarantee that the matrix is valid.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonTransforms.vtkHomogeneousTransform:
|
| homogeneous_inverse
| read-only, calls GetHomogeneousInverse
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonTransforms.vtkAbstractTransform:
|
| DeepCopy(...)
| DeepCopy(self, __a:vtkAbstractTransform) -> None
| C++: void DeepCopy(vtkAbstractTransform *)
|
| Copy this transform from another of the same type.
|
| Modified(...)
| Modified(self) -> None
| C++: void Modified() override;
|
| Override Modified to avoid ModifiedEvent during update.
|
| SetInverse(...)
| SetInverse(self, transform:vtkAbstractTransform) -> None
| C++: void SetInverse(vtkAbstractTransform *transform)
|
| Set a transformation that this transform will be the inverse of.
| This transform will automatically update to agree with the
| inverse transform that you set.
|
| TransformDoubleNormalAtPoint(...)
| TransformDoubleNormalAtPoint(self, point:(float, float, float),
| normal:(float, float, float)) -> (float, float, float)
| C++: double *TransformDoubleNormalAtPoint(const double point[3],
| const double normal[3])
|
| Apply the transformation to a double-precision normal at the
| specified vertex. If the transformation is a vtkLinearTransform,
| you can use TransformDoubleNormal() instead.
|
| TransformDoublePoint(...)
| TransformDoublePoint(self, x:float, y:float, z:float) -> (float,
| float, float)
| C++: double *TransformDoublePoint(double x, double y, double z)
| TransformDoublePoint(self, point:(float, float, float)) -> (float,
| float, float)
| C++: double *TransformDoublePoint(const double point[3])
|
| Apply the transformation to a double-precision (x,y,z)
| coordinate. Use this if you are programming in Python or Java.
|
| TransformDoubleVectorAtPoint(...)
| TransformDoubleVectorAtPoint(self, point:(float, float, float),
| vector:(float, float, float)) -> (float, float, float)
| C++: double *TransformDoubleVectorAtPoint(const double point[3],
| const double vector[3])
|
| Apply the transformation to a double-precision vector at the
| specified vertex. If the transformation is a vtkLinearTransform,
| you can use TransformDoubleVector() instead.
|
| TransformFloatNormalAtPoint(...)
| TransformFloatNormalAtPoint(self, point:(float, float, float),
| normal:(float, float, float)) -> (float, float, float)
| C++: float *TransformFloatNormalAtPoint(const float point[3],
| const float normal[3])
|
| Apply the transformation to a single-precision normal at the
| specified vertex. If the transformation is a vtkLinearTransform,
| you can use TransformFloatNormal() instead.
|
| TransformFloatPoint(...)
| TransformFloatPoint(self, x:float, y:float, z:float) -> (float,
| float, float)
| C++: float *TransformFloatPoint(float x, float y, float z)
| TransformFloatPoint(self, point:(float, float, float)) -> (float,
| float, float)
| C++: float *TransformFloatPoint(const float point[3])
|
| Apply the transformation to an (x,y,z) coordinate. Use this if
| you are programming in Python or Java.
|
| TransformFloatVectorAtPoint(...)
| TransformFloatVectorAtPoint(self, point:(float, float, float),
| vector:(float, float, float)) -> (float, float, float)
| C++: float *TransformFloatVectorAtPoint(const float point[3],
| const float vector[3])
|
| Apply the transformation to a single-precision vector at the
| specified vertex. If the transformation is a vtkLinearTransform,
| you can use TransformFloatVector() instead.
|
| TransformNormalAtPoint(...)
| TransformNormalAtPoint(self, point:(float, float, float), in_:(
| float, float, float), out:[float, float, float]) -> None
| C++: void TransformNormalAtPoint(const double point[3],
| const double in[3], double out[3])
| TransformNormalAtPoint(self, point:(float, float, float), normal:(
| float, float, float)) -> (float, float, float)
| C++: double *TransformNormalAtPoint(const double point[3],
| const double normal[3])
|
| TransformPoint(...)
| TransformPoint(self, in_:(float, float, float), out:[float, float,
| float]) -> None
| C++: void TransformPoint(const double in[3], double out[3])
| TransformPoint(self, x:float, y:float, z:float) -> (float, float,
| float)
| C++: double *TransformPoint(double x, double y, double z)
| TransformPoint(self, point:(float, float, float)) -> (float,
| float, float)
| C++: double *TransformPoint(const double point[3])
|
| Apply the transformation to a double-precision coordinate. You
| can use the same array to store both the input and output point.
|
| TransformVectorAtPoint(...)
| TransformVectorAtPoint(self, point:(float, float, float), in_:(
| float, float, float), out:[float, float, float]) -> None
| C++: void TransformVectorAtPoint(const double point[3],
| const double in[3], double out[3])
| TransformVectorAtPoint(self, point:(float, float, float), vector:(
| float, float, float)) -> (float, float, float)
| C++: double *TransformVectorAtPoint(const double point[3],
| const double vector[3])
|
| Update(...)
| Update(self) -> None
| C++: void Update()
|
| Update the transform to account for any changes which have been
| made. You do not have to call this method yourself, it is called
| automatically whenever the transform needs an update.
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| AddObserver(...)
| AddObserver(self, event:int, command:Callback, priority:float=0.0) -> int
| C++: unsigned long AddObserver(const char* event,
| vtkCommand* command, float priority=0.0f)
|
| Add an event callback command(o:vtkObject, event:int) for an event type.
| Returns a handle that can be used with RemoveEvent(event:int).
|
| BreakOnError(...)
| BreakOnError() -> None
| C++: static void BreakOnError()
|
| This method is called when vtkErrorMacro executes. It allows the
| debugger to break on error.
|
| DebugOff(...)
| DebugOff(self) -> None
| C++: virtual void DebugOff()
|
| Turn debugging output off.
|
| DebugOn(...)
| DebugOn(self) -> None
| C++: virtual void DebugOn()
|
| Turn debugging output on.
|
| GetCommand(...)
| GetCommand(self, tag:int) -> vtkCommand
| C++: vtkCommand *GetCommand(unsigned long tag)
|
| GetDebug(...)
| GetDebug(self) -> bool
| C++: bool GetDebug()
|
| Get the value of the debug flag.
|
| GetGlobalWarningDisplay(...)
| GetGlobalWarningDisplay() -> int
| C++: static vtkTypeBool GetGlobalWarningDisplay()
|
| GetObjectDescription(...)
| GetObjectDescription(self) -> str
| C++: std::string GetObjectDescription() override;
|
| The object description printed in messages and PrintSelf output.
| To be used only for reporting purposes.
|
| GetObjectName(...)
| GetObjectName(self) -> str
| C++: virtual std::string GetObjectName()
|
| GlobalWarningDisplayOff(...)
| GlobalWarningDisplayOff() -> None
| C++: static void GlobalWarningDisplayOff()
|
| GlobalWarningDisplayOn(...)
| GlobalWarningDisplayOn() -> None
| C++: static void GlobalWarningDisplayOn()
|
| HasObserver(...)
| HasObserver(self, event:int, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
| HasObserver(self, event:str, __b:vtkCommand) -> int
| C++: vtkTypeBool HasObserver(const char *event, vtkCommand *)
| HasObserver(self, event:int) -> int
| C++: vtkTypeBool HasObserver(unsigned long event)
| HasObserver(self, event:str) -> int
| C++: vtkTypeBool HasObserver(const char *event)
|
| InvokeEvent(...)
| InvokeEvent(self, event:int, callData:Any) -> int
| C++: int InvokeEvent(unsigned long event, void* callData)
| InvokeEvent(self, event:str, callData:Any) -> int
| C++: int InvokeEvent(const char* event, void* callData)
| InvokeEvent(self, event:int) -> int
| C++: int InvokeEvent(unsigned long event)
| InvokeEvent(self, event:str) -> int
| C++: int InvokeEvent(const char* event)
|
| This method invokes an event and returns whether the event was
| aborted or not. If the event was aborted, the return value is 1,
| otherwise it is 0.
|
| RemoveAllObservers(...)
| RemoveAllObservers(self) -> None
| C++: void RemoveAllObservers()
|
| RemoveObserver(...)
| RemoveObserver(self, __a:vtkCommand) -> None
| C++: void RemoveObserver(vtkCommand *)
| RemoveObserver(self, tag:int) -> None
| C++: void RemoveObserver(unsigned long tag)
|
| RemoveObservers(...)
| RemoveObservers(self, event:int, __b:vtkCommand) -> None
| C++: void RemoveObservers(unsigned long event, vtkCommand *)
| RemoveObservers(self, event:str, __b:vtkCommand) -> None
| C++: void RemoveObservers(const char *event, vtkCommand *)
| RemoveObservers(self, event:int) -> None
| C++: void RemoveObservers(unsigned long event)
| RemoveObservers(self, event:str) -> None
| C++: void RemoveObservers(const char *event)
|
| SetDebug(...)
| SetDebug(self, debugFlag:bool) -> None
| C++: void SetDebug(bool debugFlag)
|
| Set the value of the debug flag. A true value turns debugging on.
|
| SetGlobalWarningDisplay(...)
| SetGlobalWarningDisplay(val:int) -> None
| C++: static void SetGlobalWarningDisplay(vtkTypeBool val)
|
| This is a global flag that controls whether any debug, warning or
| error messages are displayed.
|
| SetObjectName(...)
| SetObjectName(self, objectName:str) -> None
| C++: virtual void SetObjectName(const std::string &objectName)
|
| Set/get the name of this object for reporting purposes. The name
| appears in warning and debug messages and in the Print output.
| Setting the object name does not change the MTime and does not
| invoke a ModifiedEvent. Derived classes implementing copying
| methods are expected not to copy the ObjectName.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObject:
|
| debug
| read-write, calls GetDebug/SetDebug
|
| global_warning_display
| read-write, calls GetGlobalWarningDisplay/SetGlobalWarningDisplay
|
| object_description
| read-only, calls GetObjectDescription
|
| object_name
| read-write, calls GetObjectName/SetObjectName
|
| ----------------------------------------------------------------------
| Methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| FastDelete(...)
| FastDelete(self) -> None
| C++: virtual void FastDelete()
|
| Delete a reference to this object. This version will not invoke
| garbage collection and can potentially leak the object if it is
| part of a reference loop. Use this method only when it is known
| that the object has another reference and would not be collected
| if a full garbage collection check were done.
|
| GetAddressAsString(...)
| GetAddressAsString(self, classname:str) -> str
|
| Get address of C++ object in format 'Addr=%p' after casting to
| the specified type. This method is obsolete, you can get the
| same information from o.__this__.
|
| GetClassName(...)
| GetClassName(self) -> str
| C++: const char *GetClassName()
|
| Return the class name as a string.
|
| GetIsInMemkind(...)
| GetIsInMemkind(self) -> bool
| C++: bool GetIsInMemkind()
|
| A local state flag that remembers whether this object lives in
| the normal or extended memory space.
|
| GetReferenceCount(...)
| GetReferenceCount(self) -> int
| C++: int GetReferenceCount()
|
| Return the current reference count of this object.
|
| GetUsingMemkind(...)
| GetUsingMemkind() -> bool
| C++: static bool GetUsingMemkind()
|
| A global state flag that controls whether vtkObjects are
| constructed in the usual way (the default) or within the extended
| memory space.
|
| InitializeObjectBase(...)
| InitializeObjectBase(self) -> None
| C++: void InitializeObjectBase()
|
| Register(...)
| Register(self, o:vtkObjectBase)
| C++: virtual void Register(vtkObjectBase *o)
|
| Increase the reference count by 1.
|
| SetMemkindDirectory(...)
| SetMemkindDirectory(directoryname:str) -> None
| C++: static void SetMemkindDirectory(const char *directoryname)
|
| The name of a directory, ideally mounted -o dax, to memory map an
| extended memory space within. This must be called before any
| objects are constructed in the extended space. It can not be
| changed once setup.
|
| SetReferenceCount(...)
| SetReferenceCount(self, __a:int) -> None
| C++: void SetReferenceCount(int)
|
| Sets the reference count. (This is very dangerous, use with
| care.)
|
| UnRegister(...)
| UnRegister(self, o:vtkObjectBase)
| C++: virtual void UnRegister(vtkObjectBase* o)
|
| Decrease the reference count (release by another object). This
| has the same effect as invoking Delete() (i.e., it reduces the
| reference count by 1).
|
| UsesGarbageCollector(...)
| UsesGarbageCollector(self) -> bool
| C++: virtual bool UsesGarbageCollector()
|
| Indicate whether the class uses `vtkGarbageCollector` or not.
|
| Most classes will not need to do this, but if the class
| participates in a strongly-connected reference count cycle,
| participation can resolve these cycles.
|
| If overriding this method to return true, the `ReportReferences`
| method should be overridden to report references that may be in
| cycles.
|
| ----------------------------------------------------------------------
| Class methods inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| override(...)
| This method can be used to override a VTK class with a Python subclass.
| The class type passed to override will afterwards be instantiated
| instead of the type override is called on.
| For example,
|
| class foo(vtk.vtkPoints):
| pass
| vtk.vtkPoints.override(foo)
|
| will lead to foo being instantied every time vtkPoints() is called.
| The main objective of this functionality is to enable developers to
| extend VTK classes with more pythonic subclasses that contain
| convenience functionality.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from vtkmodules.vtkCommonCore.vtkObjectBase:
|
| class_name
| read-only, calls GetClassName
|
| is_in_memkind
| read-only, calls GetIsInMemkind
|
| memkind_directory
| write-only, calls SetMemkindDirectory
|
| reference_count
| read-write, calls GetReferenceCount/SetReferenceCount
|
| using_memkind
| read-only, calls GetUsingMemkind
DATA
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
TYPE_CHECKING = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\transform.py
pyvista.transform_vectors_sph_to_cart
Python Library Documentation: function transform_vectors_sph_to_cart in module pyvista.core.utilities.features
transform_vectors_sph_to_cart(theta, phi, r, u, v, w)
Transform vectors from spherical (r, phi, theta) to cartesian coordinates (z, y, x).
Note the "reverse" order of arrays's axes, commonly used in geosciences.
Parameters
----------
theta : array_like[float]
Azimuthal angle in degrees ``[0, 360]`` of shape ``(M,)``.
phi : array_like[float]
Polar (zenith) angle in degrees ``[0, 180]`` of shape ``(N,)``.
r : array_like[float]
Distance (radius) from the point of origin of shape ``(P,)``.
u : array_like[float]
X-component of the vector of shape ``(P, N, M)``.
v : array_like[float]
Y-component of the vector of shape ``(P, N, M)``.
w : array_like[float]
Z-component of the vector of shape ``(P, N, M)``.
Returns
-------
u_t, v_t, w_t : :class:`numpy.ndarray`
Arrays of transformed x-, y-, z-components, respectively.
pyvista.transformations
Python Library Documentation: module pyvista.core.utilities.transformations in pyvista.core.utilities
NAME
pyvista.core.utilities.transformations - Module implementing point transformations and their matrices.
FUNCTIONS
apply_transformation_to_points(transformation: 'NumpyArray[float]', points: 'NumpyArray[float]', inplace: 'Literal[True, False]' = False) -> 'NumpyArray[float] | None'
Apply a given transformation matrix (3x3 or 4x4) to a set of points.
Parameters
----------
transformation : np.ndarray
Transformation matrix of shape (3, 3) or (4, 4).
points : np.ndarray
Array of points to be transformed of shape (N, 3).
inplace : bool, default: False
Updates points in-place while returning nothing.
Returns
-------
numpy.ndarray
Transformed points.
Examples
--------
Scale a set of points in-place.
>>> import numpy as np
>>> import pyvista as pv
>>> from pyvista import examples
>>> points = examples.load_airplane().points
>>> points_orig = points.copy()
>>> scale_factor = 2
>>> tf = scale_factor * np.eye(4)
>>> tf[3, 3] = 1
>>> pv.core.utilities.transformations.apply_transformation_to_points(
... tf, points, inplace=True
... )
>>> assert np.all(np.isclose(points, scale_factor * points_orig))
axis_angle_rotation(axis: 'VectorLike[float]', angle: 'float', point: 'VectorLike[float] | None' = None, deg: 'bool' = True) -> 'NumpyArray[float]'
Return a 4x4 matrix for rotation about any axis by given angle.
Rotations around an axis that contains the origin can easily be
computed using Rodrigues' rotation formula. The key quantity is
the ``K`` cross product matrix for the unit vector ``n`` defining
the axis of the rotation:
/ 0 -nz ny \
K = | nz 0 -nx |
\ -ny nx 0 /
For a rotation angle ``phi`` around the vector ``n`` the rotation
matrix is given by
R = I + sin(phi) K + (1 - cos(phi)) K^2
where ``I`` is the 3-by-3 unit matrix and ``K^2`` denotes the matrix
square of ``K``.
If the rotation axis doesn't contain the origin, we have to first
shift real space to transform the axis' ``p0`` reference point into
the origin, then shift the points back after rotation:
p' = R @ (p - p0) + p0 = R @ p + (p0 - R @ p0)
This means that the rotation in general consists of a 3-by-3
rotation matrix ``R``, and a translation given by
``b = p0 - R @ p0``. These can be encoded in a 4-by-4 transformation
matrix by filling the 3-by-3 leading principal submatrix with ``R``,
and filling the top 3 values in the last column with ``b``.
Parameters
----------
axis : sequence[float]
The direction vector of the rotation axis. It need not be a
unit vector, but it must not be a zero vector.
angle : float
Angle of rotation around the axis. The angle is defined as a
counterclockwise rotation when facing the normal vector of the
rotation axis. Passed either in degrees or radians depending on
the value of ``deg``.
point : sequence[float], optional
The origin of the rotation (a reference point through which the
rotation axis passes). By default the rotation axis contains the
origin.
deg : bool, default: True
Whether the angle is specified in degrees. ``False`` implies
radians.
Returns
-------
numpy.ndarray
The ``(4, 4)`` rotation matrix.
Examples
--------
Generate a transformation matrix for rotation around a cube's body
diagonal by 120 degrees.
>>> import numpy as np
>>> from pyvista import transformations
>>> trans = transformations.axis_angle_rotation([1, 1, 1], 120)
Check that the transformation cycles the cube's three corners.
>>> corners = np.array(
... [
... [1, 0, 0],
... [0, 1, 0],
... [0, 0, 1],
... ]
... )
>>> rotated = transformations.apply_transformation_to_points(
... trans, corners
... )
>>> np.allclose(rotated, corners[[1, 2, 0], :])
True
decomposition(transformation: 'TransformLike', *, homogeneous: 'bool' = False) -> '_FiveArrays'
Decompose a transformation into its components.
The transformation matrix ``M`` is decomposed into five components:
- translation ``T``
- rotation ``R``
- reflection ``N``
- scaling ``S``
- shearing ``K``
such that, when represented as 4x4 matrices, ``M = TRNSK``. The decomposition is
unique and is computed with polar matrix decomposition.
By default, compact representations of the transformations are returned (e.g. as a
3-element vector or a 3x3 matrix). Optionally, 4x4 matrices may be returned instead.
.. note::
- The rotation is orthonormal and right-handed with positive determinant.
- The scaling factors are positive.
- The reflection is either ``1`` (no reflection) or ``-1`` (has reflection)
and can be used like a scaling factor.
Parameters
----------
transformation : TransformLike
Array or transform to decompose.
homogeneous : bool, default: False
If ``True``, return the components (translation, rotation, etc.) as 4x4
homogeneous matrices. By default, reflection is a scalar, translation and
scaling are length-3 vectors, and rotation and shear are 3x3 matrices.
Returns
-------
numpy.ndarray
Translation component ``T``. Returned as a 3-element vector (or a 4x4
translation matrix if ``homogeneous`` is ``True``).
numpy.ndarray
Rotation component ``R``. Returned as a 3x3 orthonormal rotation matrix of row
vectors (or a 4x4 rotation matrix if ``homogeneous`` is ``True``).
numpy.ndarray
Reflection component ``N``. Returned as a NumPy scalar (or a 4x4 reflection
matrix if ``homogeneous`` is ``True``).
numpy.ndarray
Scaling component ``S``. Returned as a 3-element vector (or a 4x4 scaling matrix
if ``homogeneous`` is ``True``).
numpy.ndarray
Shear component ``K``. Returned as a 3x3 matrix with ones on the diagonal and
shear values in the off-diagonals (or as a 4x4 shearing matrix if ``homogeneous``
is ``True``).
Examples
--------
Decompose a transformation matrix which has scaling, rotation, and translation.
>>> import pyvista as pv
>>> matrix = [
... [0.0, -2.0, 0.0, 4.0],
... [1.0, 0.0, 0.0, 5.0],
... [0.0, 0.0, 3.0, 6.0],
... [0.0, 0.0, 0.0, 1.0],
... ]
>>> T, R, N, S, K = pv.transformations.decomposition(matrix)
Since the input has no shear, this component is the identity matrix.
>>> K # shear
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
>>> S # scale
array([1., 2., 3.])
There is no reflection so this component is ``1``.
>>> N # reflection
array(1.)
>>> R # rotation
array([[ 0., -1., 0.],
[ 1., 0., 0.],
[ 0., 0., 1.]])
>>> T # translation
array([4., 5., 6.])
Repeat the example, but this time with a small shear component of 0.1. Note how the
presence of shear also affects the values of the scaling and rotation components.
>>> matrix = [
... [0.0, -2.0, 0.0, 4.0],
... [1.0, 0.1, 0.0, 5.0],
... [0.0, 0.0, 3.0, 6.0],
... [0.0, 0.0, 0.0, 1.0],
... ]
>>> T, R, N, S, K = pv.transformations.decomposition(matrix)
>>> K # shear
array([[1. , 0.03333333, 0. ],
[0.01663894, 1. , 0. ],
[0. , 0. , 1. ]])
>>> S # scale
array([0.99944491, 2.0022213 , 3. ])
>>> N # reflection
array(1.)
>>> R # rotation
array([[ 0.03331483, -0.99944491, 0. ],
[ 0.99944491, 0.03331483, 0. ],
[ 0. , 0. , 1. ]])
>>> T # translation
array([4., 5., 6.])
reflection(normal: 'VectorLike[float]', point: 'VectorLike[float] | None' = None) -> 'NumpyArray[float]'
Return a 4x4 matrix for reflection across a normal about a point.
Projection to a unit vector ``n`` can be computed using the dyadic
product (or outer product) ``P`` of ``n`` with itself, which is a
3-by-3 symmetric matrix.
Reflection across a plane that contains the origin amounts to
reversing the components of real space points that are perpendicular
to the reflection plane. This gives us the transformation ``R``
acting on a point ``p`` as
p' = R @ p = p - 2 P @ p = (I - 2 P) @ p
so the reflection's transformation matrix is the unit matrix minus
twice the dyadic product ``P``.
If additionally we want to compute a reflection to a plane that does
not contain the origin, we can we can first shift every point in
real space by ``-p0`` (if ``p0`` is a point that lies on the plane)
p' = R @ (p - p0) + p0 = R @ p + (p0 - R @ p0)
This means that the reflection in general consists of a 3-by-3
reflection matrix ``R``, and a translation given by
``b = p0 - R @ p0``. These can be encoded in a 4-by-4 transformation
matrix by filling the 3-by-3 leading principal submatrix with ``R``,
and filling the top 3 values in the last column with ``b``.
Parameters
----------
normal : sequence[float]
The normal vector of the reflection plane. It need not be a unit
vector, but it must not be a zero vector.
point : sequence[float], optional
The origin of the reflection (a reference point through which
the reflection plane passes). By default the reflection plane
contains the origin.
Returns
-------
ndarray
A ``(4, 4)`` transformation matrix for reflecting points across the
plane defined by the given normal and point.
Examples
--------
Generate a transformation matrix for reflection over the XZ plane.
>>> import numpy as np
>>> from pyvista import transformations
>>> trans = transformations.reflection([0, 1, 0])
Check that the reflection transforms corners of a cube among one
another.
>>> verts = np.array(
... [
... [1, -1, 1],
... [-1, -1, 1],
... [-1, -1, -1],
... [-1, -1, 1],
... [1, 1, 1],
... [-1, 1, 1],
... [-1, 1, -1],
... [-1, 1, 1],
... ]
... )
>>> mirrored = transformations.apply_transformation_to_points(trans, verts)
>>> np.allclose(mirrored, verts[[np.r_[4:8, 0:4]], :])
True
DATA
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
TYPE_CHECKING = False
TypeAlias = typing.TypeAlias
Special form for marking type aliases.
Use TypeAlias to indicate that an assignment should
be recognized as a proper type alias definition by type
checkers.
For example::
Predicate: TypeAlias = Callable[..., bool]
It's invalid when used anywhere except as in the example above.
__annotations__ = {}
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\transformations.py
pyvista.translate
Python Library Documentation: function translate in module pyvista.core.utilities.geometric_sources
translate(surf: 'DataSet', center: 'VectorLike[float]' = (0.0, 0.0, 0.0), direction: 'VectorLike[float]' = (1.0, 0.0, 0.0)) -> 'None'
Translate and orient a mesh to a new center and direction.
By default, the input mesh is considered centered at the origin
and facing in the x direction.
Parameters
----------
surf : pyvista.core.pointset.PolyData
Mesh to be translated and oriented.
center : tuple, optional, default: (0.0, 0.0, 0.0)
Center point to which the mesh should be translated.
direction : tuple, optional, default: (1.0, 0.0, 0.0)
Direction vector along which the mesh should be oriented.
pyvista.try_callback
Python Library Documentation: function try_callback in module pyvista.core.utilities.misc
try_callback(func, *args) -> 'None'
Wrap a given callback in a try statement.
Parameters
----------
func : callable
Callable object.
*args
Any arguments.
pyvista.typing
Python Library Documentation: package pyvista.typing in pyvista
NAME
pyvista.typing - PyVista plugin for static type-checking with mypy.
PACKAGE CONTENTS
mypy_plugin
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\typing\__init__.py
pyvista.unregister_dataset_accessor
Python Library Documentation: function unregister_dataset_accessor in module pyvista.core.utilities.accessor_registry
unregister_dataset_accessor(name: 'str', target_cls: 'type') -> 'None'
Remove an accessor previously attached to a target class.
The inverse of :func:`~pyvista.register_dataset_accessor`. Restores
any built-in attribute that was shadowed via ``override=True`` when
the accessor was registered.
.. versionadded:: 0.48.0
Parameters
----------
name : str
Namespace of the accessor to remove.
target_cls : type
Target class the accessor was registered against. Only accessors
attached directly on ``target_cls`` can be unregistered; an
accessor inherited from a parent class must be unregistered on
that parent.
Raises
------
ValueError
If no accessor named ``name`` is attached directly to
``target_cls``.
TypeError
If ``target_cls`` is not a class, or ``name`` is not a string.
Examples
--------
>>> import pyvista as pv
>>> @pv.register_dataset_accessor('tmp', pv.PolyData)
... class TmpAccessor:
... def __init__(self, mesh):
... self._mesh = mesh
>>> pv.unregister_dataset_accessor('tmp', pv.PolyData)
pyvista.utilities
Python Library Documentation: package pyvista.core.utilities in pyvista.core
NAME
pyvista.core.utilities - Utilities routines.
PACKAGE CONTENTS
_frd
_registry_helpers
accessor_registry
arrays
cell_quality
cells
docs
features
fileio
geometric_objects
geometric_sources
helpers
image_sources
misc
observers
parametric_objects
points
reader
reader_registry
state_manager
transform
transformations
writer
writer_registry
DATA
allow_new_attributes = <pyvista.core.utilities.state_manager._AllowNew...
vtk_snake_case = <pyvista.core.utilities.state_manager._vtkSnakeCase o...
vtk_verbosity = <pyvista.core.utilities.state_manager._VTKVerbosity ob...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\__init__.py
pyvista.vector_poly_data
Python Library Documentation: function vector_poly_data in module pyvista.core.utilities.points
vector_poly_data(orig: 'VectorLike[float] | MatrixLike[float]', vec: 'VectorLike[float] | MatrixLike[float]') -> 'PolyData'
Create a pyvista.PolyData object composed of vectors.
Parameters
----------
orig : array_like[float]
Array of vector origins.
vec : array_like[float]
Array of vectors.
Returns
-------
pyvista.PolyData
Mesh containing the ``orig`` points along with the
``'vectors'`` and ``'mag'`` point arrays representing the
vectors and magnitude of the vectors at each point.
Examples
--------
Create basic vector field. This is a point cloud where each point
has a vector and magnitude attached to it.
>>> import pyvista as pv
>>> import numpy as np
>>> x, y = np.meshgrid(np.linspace(-5, 5, 10), np.linspace(-5, 5, 10))
>>> points = np.vstack((x.ravel(), y.ravel(), np.zeros(x.size))).T
>>> u = x / np.sqrt(x**2 + y**2)
>>> v = y / np.sqrt(x**2 + y**2)
>>> vectors = np.vstack((u.ravel() ** 3, v.ravel() ** 3, np.zeros(u.size))).T
>>> pdata = pv.vector_poly_data(points, vectors)
>>> pdata.point_data.keys()
['vectors', 'mag']
Convert these to arrows and plot it.
>>> pdata.glyph(orient='vectors', scale='mag').plot()
pyvista.version_info
Python Library Documentation: tuple object class tuple(object) | tuple(iterable=(), /) | | Built-in immutable sequence. | | If no argument is given, the constructor returns an empty tuple. | If iterable is specified the tuple is initialized from iterable's items. | | If the argument is a tuple, the return value is the same object. | | Built-in subclasses: | asyncgen_hooks | UnraisableHookArgs | | Methods defined here: | | __add__(self, value, /) | Return self+value. | | __contains__(self, key, /) | Return bool(key in self). | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(self, key, /) | Return self[key]. | | __getnewargs__(self, /) | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __iter__(self, /) | Implement iter(self). | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | __rmul__(self, value, /) | Return value*self. | | count(self, value, /) | Return number of occurrences of value. | | index(self, value, start=0, stop=9223372036854775807, /) | Return first index of value. | | Raises ValueError if the value is not present. | | ---------------------------------------------------------------------- | Class methods defined here: | | __class_getitem__(...) | See PEP 585 | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) | Create and return a new object. See help(type) for accurate signature.
pyvista.voxelize
Python Library Documentation: function voxelize in module pyvista.core.utilities.features
voxelize(mesh, density=None, check_surface: 'bool' = True, enclosed: 'bool' = False, fit_bounds: 'bool' = False)
Voxelize mesh to UnstructuredGrid.
.. deprecated:: 0.46
This function is deprecated. Use :meth:`pyvista.DataSetFilters.voxelize` instead.
Parameters
----------
mesh : pyvista.DataSet
Mesh to voxelize.
density : float | array_like[float]
The uniform size of the voxels when single float passed.
A list of densities along x,y,z directions.
Defaults to 1/100th of the mesh length.
check_surface : bool, default: True
Specify whether to check the surface for closure. If on, then the
algorithm first checks to see if the surface is closed and
manifold. If the surface is not closed and manifold, a runtime
error is raised.
enclosed : bool, default: False
If True, the voxel bounds will be outside the mesh.
If False, the voxel bounds will be at or inside the mesh bounds.
fit_bounds : bool, default: False
If enabled, the end bound of the input mesh is used as the end bound of the
voxel grid and the density is updated to the closest compatible one. Otherwise,
the end bound is excluded. Has no effect if `enclosed` is enabled.
Returns
-------
pyvista.UnstructuredGrid
Voxelized unstructured grid of the original mesh.
Notes
-----
Prior to version 0.39.0, this method improperly handled the order of
structured coordinates.
See Also
--------
pyvista.DataSetFilters.voxelize_rectilinear
Similar function that returns a :class:`pyvista.RectilinearGrid` with cell data.
pyvista.DataSetFilters.voxelize_binary_mask
Similar function that returns a :class:`pyvista.ImageData` with point data.
Examples
--------
Create an equal density voxelized mesh.
>>> import pyvista as pv
>>> from pyvista import examples
>>> mesh = examples.download_bunny_coarse().clean() # doctest:+SKIP
>>> vox = pv.voxelize(mesh, density=0.01) # doctest:+SKIP
>>> vox.plot(show_edges=True) # doctest:+SKIP
Create a voxelized mesh using unequal density dimensions.
>>> vox = pv.voxelize(mesh, density=[0.01, 0.005, 0.002]) # doctest:+SKIP
>>> vox.plot(show_edges=True) # doctest:+SKIP
Create an equal density voxel volume without enclosing input mesh.
>>> vox = pv.voxelize(mesh, density=0.01) # doctest:+SKIP
>>> vox = vox.select_enclosed_points(mesh, tolerance=0.0) # doctest:+SKIP
>>> vox.plot(scalars='SelectedPoints', show_edges=True) # doctest:+SKIP
Create an equal density voxel volume enclosing input mesh.
>>> vox = pv.voxelize(mesh, density=0.01, enclosed=True) # doctest:+SKIP
>>> vox = vox.select_enclosed_points(mesh, tolerance=0.0) # doctest:+SKIP
>>> vox.plot(scalars='SelectedPoints', show_edges=True) # doctest:+SKIP
Create a voxelized mesh that does not fit the input mesh's bounds. Notice the
cropped rectangular box.
>>> mesh = pv.Cube(x_length=0.25) # doctest:+SKIP
>>> vox = pv.voxelize(mesh=mesh, density=0.2) # doctest:+SKIP
>>> pl = pv.Plotter() # doctest:+SKIP
>>> _ = pl.add_mesh(mesh=vox, show_edges=True, color='yellow') # doctest:+SKIP
>>> _ = pl.add_mesh(
... mesh=mesh, show_edges=True, line_width=5, opacity=0.4
... ) # doctest:+SKIP
>>> pl.show() # doctest:+SKIP
Create a voxelized mesh that fits the input mesh's bounds. The rectangular mesh is
now complete. Notice that the voxel size was updated to fit the bounds in the first
direction.
>>> vox = pv.voxelize(mesh=mesh, density=0.2, fit_bounds=True) # doctest:+SKIP
>>> pl = pv.Plotter() # doctest:+SKIP
>>> _ = pl.add_mesh(mesh=vox, show_edges=True, color='yellow') # doctest:+SKIP
>>> _ = pl.add_mesh(
... mesh=mesh, show_edges=True, line_width=5, opacity=0.4
... ) # doctest:+SKIP
>>> pl.show() # doctest:+SKIP
pyvista.voxelize_volume
Python Library Documentation: function voxelize_volume in module pyvista.core.utilities.features
voxelize_volume(mesh, density=None, check_surface: 'bool' = True, enclosed: 'bool' = False, fit_bounds: 'bool' = False)
Voxelize mesh to create a RectilinearGrid voxel volume.
Creates a voxel volume that encloses the input mesh and discretizes the cells
within the volume that intersect or are contained within the input mesh.
``InsideMesh``, an array in ``cell_data``, is ``1`` for cells inside and ``0`` outside.
.. deprecated:: 0.46
This function is deprecated. Use :meth:`pyvista.DataSetFilters.voxelize_rectilinear`
instead.
Parameters
----------
mesh : pyvista.DataSet
Mesh to voxelize.
density : float | array_like[float]
The uniform size of the voxels when single float passed.
Nonuniform voxel size if a list of values are passed along x,y,z directions.
Defaults to 1/100th of the mesh length.
check_surface : bool, default: True
Specify whether to check the surface for closure. If on, then the
algorithm first checks to see if the surface is closed and
manifold. If the surface is not closed and manifold, a runtime
error is raised.
enclosed : bool, default: False
If True, the voxel bounds will be outside the mesh.
If False, the voxel bounds will be at or inside the mesh bounds.
fit_bounds : bool, default: False
If enabled, the end bound of the input mesh is used as the end bound of the
voxel grid and the density is updated to the closest compatible one. Otherwise,
the end bound is excluded. Has no effect if `enclosed` is enabled.
Returns
-------
pyvista.RectilinearGrid
RectilinearGrid as voxelized volume with discretized cells.
See Also
--------
pyvista.DataSetFilters.voxelize
Similar function that returns a :class:`pyvista.UnstructuredGrid` of
:attr:`~pyvista.CellType.VOXEL` cells.
pyvista.DataSetFilters.voxelize_binary_mask
Similar function that returns a :class:`pyvista.ImageData` with point data.
pyvista.DataSetFilters.select_enclosed_points
Examples
--------
Create an equal density voxel volume from input mesh.
>>> import pyvista as pv
>>> import numpy as np
Load file from PyVista examples.
>>> from pyvista import examples
>>> mesh = examples.download_cow() # doctest:+SKIP
Create an equal density voxel volume and plot the result.
>>> vox = pv.voxelize_volume(mesh, density=0.15) # doctest:+SKIP
>>> cpos = [(15, 3, 15), (0, 0, 0), (0, 0, 0)] # doctest:+SKIP
>>> vox.plot(scalars='InsideMesh', show_edges=True, cpos=cpos) # doctest:+SKIP
Slice the voxel volume to view ``InsideMesh``.
>>> slices = vox.slice_orthogonal() # doctest:+SKIP
>>> slices.plot(scalars='InsideMesh', show_edges=True) # doctest:+SKIP
Create a voxel volume from unequal density dimensions and plot result.
>>> vox = pv.voxelize_volume(mesh, density=[0.15, 0.15, 0.5]) # doctest:+SKIP
>>> vox.plot(scalars='InsideMesh', show_edges=True, cpos=cpos) # doctest:+SKIP
Slice the unequal density voxel volume to view ``InsideMesh``.
>>> slices = vox.slice_orthogonal() # doctest:+SKIP
>>> slices.plot(
... scalars='InsideMesh', show_edges=True, cpos=cpos
... ) # doctest:+SKIP
Create an equal density voxel volume without enclosing input mesh.
>>> vox = pv.voxelize_volume(mesh, density=0.15) # doctest:+SKIP
>>> vox = vox.select_enclosed_points(mesh, tolerance=0.0) # doctest:+SKIP
>>> vox.plot(
... scalars='SelectedPoints', show_edges=True, cpos=cpos
... ) # doctest:+SKIP
Create an equal density voxel volume enclosing input mesh.
>>> vox = pv.voxelize_volume(
... mesh, density=0.15, enclosed=True
... ) # doctest:+SKIP
>>> vox = vox.select_enclosed_points(mesh, tolerance=0.0) # doctest:+SKIP
>>> vox.plot(
... scalars='SelectedPoints', show_edges=True, cpos=cpos
... ) # doctest:+SKIP
Create an equal density voxel volume that does not fit the input mesh's bounds.
>>> mesh = pv.examples.load_nut() # doctest:+SKIP
>>> vox = pv.voxelize_volume(mesh=mesh, density=2.5) # doctest:+SKIP
>>> pl = pv.Plotter() # doctest:+SKIP
>>> _ = pl.add_mesh(mesh=vox, show_edges=True) # doctest:+SKIP
>>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1) # doctest:+SKIP
>>> pl.show() # doctest:+SKIP
Create an equal density voxel volume that fits the input mesh's bounds.
>>> vox = pv.voxelize_volume(
... mesh=mesh, density=2.5, fit_bounds=True
... ) # doctest:+SKIP
>>> pl = pv.Plotter() # doctest:+SKIP
>>> _ = pl.add_mesh(mesh=vox, show_edges=True) # doctest:+SKIP
>>> _ = pl.add_mesh(mesh=mesh, show_edges=True, opacity=1) # doctest:+SKIP
>>> pl.show() # doctest:+SKIP
pyvista.vtk_bit_array_to_char
Python Library Documentation: function vtk_bit_array_to_char in module pyvista.core.utilities.arrays
vtk_bit_array_to_char(vtkarr_bint: '_vtk.vtkBitArray') -> '_vtk.vtkCharArray'
Cast vtk bit array to a char array.
Parameters
----------
vtkarr_bint : :vtk:`vtkBitArray`
VTK binary array.
Returns
-------
:vtk:`vtkCharArray`
VTK char array.
Notes
-----
This performs a copy.
pyvista.vtk_id_list_to_array
Python Library Documentation: function vtk_id_list_to_array in module pyvista.core.utilities.arrays
vtk_id_list_to_array(vtk_id_list: '_vtk.vtkIdList') -> 'NumpyArray[int]'
Convert a :vtk:`vtkIdList` to a NumPy array.
Parameters
----------
vtk_id_list : :vtk:`vtkIdList`
VTK ID list.
Returns
-------
numpy.ndarray
Array of IDs.
pyvista.vtk_points
Python Library Documentation: function vtk_points in module pyvista.core.utilities.points
vtk_points(points: 'VectorLike[float] | MatrixLike[float]', deep: 'bool' = True, force_float: 'bool' = False, allow_empty: 'bool' = True) -> '_vtk.vtkPoints'
Convert numpy array or array-like to a :vtk:`vtkPoints` object.
Parameters
----------
points : numpy.ndarray or sequence
Points to convert. Should be 1 or 2 dimensional. Accepts a
single point or several points.
deep : bool, default: True
Perform a deep copy of the array. Only applicable if
``points`` is a :class:`numpy.ndarray`.
force_float : bool, default: False
Casts the datatype to ``float32`` if points datatype is
non-float. Set this to ``False`` to allow non-float types,
though this may lead to truncation of intermediate floats
when transforming datasets.
allow_empty : bool, default: True
Allow ``points`` to be an empty array. If ``False``, points
must be strictly one- or two-dimensional.
.. versionadded:: 0.45
Returns
-------
:vtk:`vtkPoints`
The :vtk:`vtkPoints` object.
Examples
--------
>>> import pyvista as pv
>>> import numpy as np
>>> points = np.random.default_rng().random((10, 3))
>>> vpoints = pv.vtk_points(points)
>>> vpoints # doctest:+SKIP
(vtkmodules.vtkCommonCore.vtkPoints)0x7f0c2e26af40
pyvista.vtk_snake_case
Python Library Documentation: _vtkSnakeCase in module pyvista.core.utilities.state_manager object
class _vtkSnakeCase(_StateManager)
| _vtkSnakeCase() -> 'None'
|
| Context manager to control access to VTK's pythonic snake_case API.
|
| VTK 9.4 introduced pythonic snake_case attributes, e.g. `output_port` instead
| of `GetOutputPort`. These can easily be confused for PyVista attributes
| which also use a snake_case convention. This class controls access to vtk's
| new interface.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| state : 'allow' | 'warning' | 'error'
| Allow or disallow the use of VTK's pythonic snake_case API with
| PyVista-wrapped VTK classes.
|
| - 'allow': Allow accessing VTK-defined snake_case attributes.
| - 'warning': Print a RuntimeWarning when accessing VTK-defined snake_case
| attributes.
| - 'error': Raise a ``PyVistaAttributeError`` when accessing
| VTK-defined snake_case attributes.
|
| Examples
| --------
| Get the current access state for VTK's snake_case api.
|
| >>> import pyvista as pv
| >>> pv.vtk_snake_case()
| 'error'
|
| The following will raise an error because the `information` property is defined
| by :vtk:`vtkDataObject` and is not part of PyVista's API.
|
| >>> # pv.PolyData().information
|
| Allow use of VTK's snake_case attributes. No warning or error is raised.
|
| >>> _ = pv.vtk_snake_case('allow')
| >>> pv.PolyData().information
| <vtkmodules.vtkCommonCore.vtkInformation...
|
| Note that this state is global and will persist between function calls. Set it
| back to its original state explicitly.
|
| >>> _ = pv.vtk_snake_case('error')
|
| Use it as a context manager instead. This way, the state is only temporarily
| modified and is automatically restored.
|
| >>> with pv.vtk_snake_case('allow'):
| ... _ = pv.PolyData().information
|
| >>> pv.vtk_snake_case()
| 'error'
|
| Method resolution order:
| _vtkSnakeCase
| _StateManager
| contextlib.AbstractContextManager
| abc.ABC
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| __orig_bases__ = (pyvista.core.utilities.state_manager._StateManager[t...
|
| __parameters__ = ()
|
| ----------------------------------------------------------------------
| Methods inherited from _StateManager:
|
| __call__(self: 'Self', state: 'T | None' = None) -> 'Self | T'
| Call the context manager.
|
| __enter__(self) -> 'None'
| Enter context manager.
|
| __exit__(self, exc_type, exc_value, traceback)
| Exit context manager and restore original state.
|
| __init__(self) -> 'None'
| Initialize context manager.
|
| ----------------------------------------------------------------------
| Class methods inherited from contextlib.AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from contextlib.AbstractContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Generic:
|
| __init_subclass__(...)
| Function to initialize subclasses.
pyvista.vtk_verbosity
Python Library Documentation: _VTKVerbosity in module pyvista.core.utilities.state_manager object
class _VTKVerbosity(_StateManager)
| _VTKVerbosity() -> 'None'
|
| Context manager to set VTK verbosity level.
|
| .. versionadded:: 0.45
|
| Parameters
| ----------
| verbosity : str
| Verbosity of the :vtk:`vtkLogger` to set.
|
| - ``'off'``: No output.
| - ``'error'``: Only error messages.
| - ``'warning'``: Errors and warnings.
| - ``'info'``: Errors, warnings, and info messages.
| - ``'max'``: All messages, including debug info.
|
| Examples
| --------
| Get the current vtk verbosity.
|
| >>> import pyvista as pv
| >>> pv.vtk_verbosity()
| 'info'
|
| Set verbosity to max.
|
| >>> _ = pv.vtk_verbosity('max')
| >>> pv.vtk_verbosity()
| 'max'
|
| Create a :func:`~pyvista.Sphere`. Note how many VTK debugging messages are now
| generated as the sphere is created.
|
| >>> mesh = pv.Sphere()
|
| Use it as a context manager to temporarily turn it off.
|
| >>> with pv.vtk_verbosity('off'):
| ... mesh = mesh.cell_quality('volume')
|
| The state is restored to its previous value outside the context.
|
| >>> pv.vtk_verbosity()
| 'max'
|
| Note that the verbosity state is global and will persist between function
| calls. If the context manager isn't used, the state needs to be reset explicitly.
| Here, we set it back to its default value.
|
| >>> _ = pv.vtk_verbosity('info')
|
| Method resolution order:
| _VTKVerbosity
| _StateManager
| contextlib.AbstractContextManager
| abc.ABC
| typing.Generic
| builtins.object
|
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| __orig_bases__ = (pyvista.core.utilities.state_manager._StateManag...i...
|
| __parameters__ = ()
|
| ----------------------------------------------------------------------
| Methods inherited from _StateManager:
|
| __call__(self: 'Self', state: 'T | None' = None) -> 'Self | T'
| Call the context manager.
|
| __enter__(self) -> 'None'
| Enter context manager.
|
| __exit__(self, exc_type, exc_value, traceback)
| Exit context manager and restore original state.
|
| __init__(self) -> 'None'
| Initialize context manager.
|
| ----------------------------------------------------------------------
| Class methods inherited from contextlib.AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| Abstract classes can override this to customize issubclass().
|
| This is invoked early on by abc.ABCMeta.__subclasscheck__().
| It should return True, False or NotImplemented. If it returns
| NotImplemented, the normal algorithm is used. Otherwise, it
| overrides the normal algorithm (and the outcome is cached).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from contextlib.AbstractContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Generic:
|
| __init_subclass__(...)
| Function to initialize subclasses.
pyvista.vtk_version_info
Python Library Documentation: VTKVersionInfo in module pyvista.core._vtk_utilities object
class VTKVersionInfo(VersionInfo)
| VTKVersionInfo(major: ForwardRef('int'), minor: ForwardRef('int'), micro: ForwardRef('int'))
|
| Method resolution order:
| VTKVersionInfo
| VersionInfo
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __ge__(self, other)
| Return self>=value.
|
| __gt__(self, other)
| Return self>value.
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| _check_min_supported(self, other: 'tuple[int, int, int]') -> 'None'
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from VersionInfo:
|
| __getnewargs__(self) from collections.VersionInfo
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.VersionInfo
| Return a nicely formatted representation string
|
| __str__(self)
| Return str(self).
|
| _asdict(self) from collections.VersionInfo
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.VersionInfo
| Return a new VersionInfo object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods inherited from VersionInfo:
|
| _make(iterable) from collections.VersionInfo
| Make a new VersionInfo object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods inherited from VersionInfo:
|
| __new__(_cls, major: ForwardRef('int'), minor: ForwardRef('int'), micro: ForwardRef('int')) from namedtuple_VersionInfo.VersionInfo
| Create new instance of VersionInfo(major, minor, micro)
|
| _format(version: 'tuple[int, int, int]')
|
| ----------------------------------------------------------------------
| Data descriptors inherited from VersionInfo:
|
| major
| Alias for field number 0
|
| minor
| Alias for field number 1
|
| micro
| Alias for field number 2
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from VersionInfo:
|
| __match_args__ = ('major', 'minor', 'micro')
|
| __orig_bases__ = (<function NamedTuple>,)
|
| _field_defaults = {}
|
| _fields = ('major', 'minor', 'micro')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __len__(self, /)
| Return len(self).
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
pyvista.vtkmatrix_from_array
Python Library Documentation: function vtkmatrix_from_array in module pyvista.core.utilities.arrays
vtkmatrix_from_array(array: 'NumpyArray[float]') -> '_vtk.vtkMatrix3x3 | _vtk.vtkMatrix4x4'
Convert a ``numpy.ndarray`` or array-like to a vtk matrix.
Parameters
----------
array : array_like[float]
The array or array-like to be converted to a vtk matrix.
Shape (3, 3) gets converted to a :vtk:`vtkMatrix3x3`, shape (4, 4)
gets converted to a :vtk:`vtkMatrix4x4`. No other shapes are valid.
Returns
-------
output : :vtk:`vtkMatrix3x3` | :vtk:`vtkMatrix4x4`
VTK matrix.
pyvista.wrap
Python Library Documentation: function wrap in module pyvista.core.utilities.helpers
wrap(dataset: '_WrappableVTKDataObjectType | DataObject | trimesh.Trimesh | meshio.Mesh | _vtk.vtkAbstractArray | NumpyArray[float] | None', *, validate: 'bool | None' = None) -> 'DataObject | pyvista_ndarray | None'
Wrap any given VTK data object to its appropriate PyVista data object.
Other formats that are supported include:
* 2D :class:`numpy.ndarray` of XYZ vertices
* 3D :class:`numpy.ndarray` representing a volume. Values will be scalars.
* 3D :class:`trimesh.Trimesh` mesh using :func:`~pyvista.from_trimesh`.
* 3D :class:`meshio.Mesh` mesh using :func:`~pyvista.from_meshio`.
.. versionchanged:: 0.38.0
If the passed object is already a wrapped PyVista object, then
this is no-op and will return that object directly. In previous
versions of PyVista, this would perform a shallow copy.
.. versionchanged:: 0.47
If wrapping a ``Trimesh`` object, any arrays are now wrapped directly
(no copies).
Parameters
----------
dataset : :class:`numpy.ndarray` | :class:`trimesh.Trimesh` | vtk.DataSet
Dataset to wrap.
validate : bool, optional
When ``True``, confirm that every point and cell data array on the
wrapped VTK dataset has a tuple count that matches the dataset's
point or cell count, and emit a :class:`~pyvista.InvalidMeshWarning`
on any mismatch. When ``False``, skip the check entirely. When
``None`` (the default), honor
:attr:`pyvista.core.config.Config.validate_on_wrap` (which itself
defaults to ``True``).
Pass ``validate=False`` in hot loops where the caller already trusts
the input, or set
``pyvista.global_config.validate_on_wrap = False`` to disable the
check globally. This only affects raw VTK dataset inputs;
``meshio`` and ``trimesh`` paths perform their own checks
independently.
.. versionadded:: 0.48
Returns
-------
pyvista.DataSet
The PyVista wrapped dataset.
See Also
--------
:ref:`wrap_trimesh_example`
Examples
--------
Wrap a numpy array representing a random point cloud.
>>> import numpy as np
>>> import pyvista as pv
>>> points = np.random.default_rng().random((10, 3))
>>> cloud = pv.wrap(points)
>>> cloud
PolyData (...)
N Cells: 10
N Points: 10
N Strips: 0
X Bounds: ...
Y Bounds: ...
Z Bounds: ...
N Arrays: 0
Wrap a VTK object.
>>> import pyvista as pv
>>> import vtk
>>> points = vtk.vtkPoints()
>>> p = [1.0, 2.0, 3.0]
>>> vertices = vtk.vtkCellArray()
>>> pid = points.InsertNextPoint(p)
>>> _ = vertices.InsertNextCell(1)
>>> _ = vertices.InsertCellPoint(pid)
>>> point = vtk.vtkPolyData()
>>> _ = point.SetPoints(points)
>>> _ = point.SetVerts(vertices)
>>> mesh = pv.wrap(point)
>>> mesh
PolyData (...)
N Cells: 1
N Points: 1
N Strips: 0
X Bounds: 1.000e+00, 1.000e+00
Y Bounds: 2.000e+00, 2.000e+00
Z Bounds: 3.000e+00, 3.000e+00
N Arrays: 0
Wrap a Trimesh object.
>>> import trimesh
>>> import pyvista as pv
>>> points = [[0, 0, 0], [0, 0, 1], [0, 1, 0]]
>>> faces = [[0, 1, 2]]
>>> tmesh = trimesh.Trimesh(points, faces=faces, process=False)
>>> mesh = pv.wrap(tmesh)
>>> mesh # doctest:+SKIP
PolyData (0x7fc55ff27ad0)
N Cells: 1
N Points: 3
X Bounds: 0.000e+00, 0.000e+00
Y Bounds: 0.000e+00, 1.000e+00
Z Bounds: 0.000e+00, 1.000e+00
N Arrays: 0
pyvista.wrappers
Python Library Documentation: module pyvista.core.wrappers in pyvista.core
NAME
pyvista.core.wrappers - Wrapper mapping.
DESCRIPTION
Setting ``pyvista._wrappers`` allows for developers to override the default class used
to coerce a :vtk:`vtkDataSet` into a pyvista object. This is useful when creating a
subclass of a :class:`pyvista.DataSet` class.
Examples
--------
A user-defined Foo class is defined that extends the functionality of
:class:`pyvista.PolyData`. This class is set as the default wrapper for
:vtk:`vtkPolyData` objects.
>>> import pyvista as pv
>>> default_wrappers = pv._wrappers.copy()
>>> class Foo(pv.PolyData):
... pass # Extend PolyData here
>>> pv._wrappers['vtkPolyData'] = Foo
>>> image = pv.ImageData()
>>> surface = image.extract_surface(algorithm=None)
>>> assert isinstance(surface, Foo)
>>> pv._wrappers = default_wrappers # reset back to default
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\wrappers.py
pyvista.writer
Error rendering doc: 'NoneType' object is not iterable
pyvista.writer_registry
Python Library Documentation: module pyvista.core.utilities.writer_registry in pyvista.core.utilities
NAME
pyvista.core.utilities.writer_registry - Pluggable writer registry for custom file formats.
CLASSES
builtins.tuple(builtins.object)
WriterRegistration
typing.Protocol(typing.Generic)
WriterHandler
class WriterHandler(typing.Protocol)
| WriterHandler(*args, **kwargs)
|
| Callable that writes *dataset* to *path*.
|
| Method resolution order:
| WriterHandler
| typing.Protocol
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __call__(self, dataset: 'DataObject', path: 'str', /, **kwargs: 'Any') -> 'None'
| Write *dataset* to *path*, consuming format-specific *kwargs*.
|
| __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __subclasshook__ = _proto_hook(other) from typing
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| __parameters__ = ()
|
| __protocol_attrs__ = {'__call__'}
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Protocol:
|
| __init_subclass__(*args, **kwargs)
| Function to initialize subclasses.
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Generic:
|
| __class_getitem__(...)
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
class WriterRegistration(builtins.tuple)
| WriterRegistration(extension: ForwardRef('str'), handler: ForwardRef('WriterHandler'), source: ForwardRef('str'))
|
| Describe one registered custom writer.
|
| Returned by :func:`~pyvista.registered_writers`.
|
| .. versionadded:: 0.48.0
|
| Attributes
| ----------
| extension : str
| File extension the writer is registered against, including the
| leading dot (e.g. ``'.myformat'``).
| handler : callable
| The writer callable.
| source : str
| Human-readable origin in the form ``'module.qualname'`` for
| explicit registrations or the entry-point ``value`` for
| plugin-discovered registrations.
|
| Method resolution order:
| WriterRegistration
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.WriterRegistration
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.WriterRegistration
| Return a nicely formatted representation string
|
| _asdict(self) from collections.WriterRegistration
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.WriterRegistration
| Return a new WriterRegistration object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.WriterRegistration
| Make a new WriterRegistration object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, extension: ForwardRef('str'), handler: ForwardRef('WriterHandler'), source: ForwardRef('str')) from namedtuple_WriterRegistration.WriterRegistration
| Create new instance of WriterRegistration(extension, handler, source)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| extension
| Alias for field number 0
|
| handler
| Alias for field number 1
|
| source
| Alias for field number 2
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'extension': ForwardRef('str'), 'handler': ForwardR...
|
| __match_args__ = ('extension', 'handler', 'source')
|
| __orig_bases__ = (<function NamedTuple>,)
|
| _field_defaults = {}
|
| _fields = ('extension', 'handler', 'source')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
FUNCTIONS
register_writer(key: 'str', handler: 'WriterHandler | None' = None, *, override: 'bool' = False) -> 'Callable[[WriterHandler], WriterHandler] | None'
Register a custom writer for a file extension.
Can be used as a plain call or as a decorator.
.. versionadded:: 0.48.0
Parameters
----------
key : str
A file extension (e.g. ``'.myformat'``).
handler : callable, optional
A callable with signature ``handler(dataset, path, **kwargs)`` that
writes *dataset* to *path*. Any extra keyword arguments passed to
:meth:`pyvista.DataObject.save` are forwarded to the handler as
``**kwargs`` — use them to expose format-specific options such as
compression level, thread count, or chunking. Handlers that do
not need per-call options can omit ``**kwargs``; a call to
:meth:`~pyvista.DataObject.save` that passes extras to such a
handler will raise :class:`TypeError` from Python itself. When
``handler`` is omitted the function acts as a decorator and
returns the decorated callable unchanged.
override : bool, default: False
If ``True``, allow overriding a built-in PyVista writer for this
extension and silence the warning that would otherwise fire when
replacing an existing custom registration.
Returns
-------
callable or None
When used as a decorator (``handler`` omitted), returns the
decorated function. Otherwise returns ``None``.
Raises
------
ValueError
If ``key`` collides with a built-in PyVista writer and *override*
is ``False``.
Warns
-----
UserWarning
If ``key`` already refers to a registered custom writer. The new
registration replaces the old one (last wins); pass
``override=True`` to silence the warning.
See Also
--------
pyvista.register_reader
Sibling API for registering custom readers.
pyvista.registered_writers
Introspect every registered writer.
Notes
-----
When :meth:`pyvista.DataObject.save` is called, registered custom
writers are dispatched *before* built-in VTK writers — mirroring
the dispatch order of :func:`pyvista.read`. Passing
``override=True`` is therefore the only way to replace a built-in
writer at save time.
Any keyword arguments passed to :meth:`~pyvista.DataObject.save`
beyond its documented parameters are forwarded verbatim to the
registered handler. When no custom writer is registered for the
target extension, extra keyword arguments raise :class:`TypeError`
from :meth:`~pyvista.DataObject.save` — PyVista never silently
drops writer options.
Examples
--------
Register a writer for a custom file extension with a
format-specific option.
>>> import pyvista as pv
>>> def my_writer(dataset, path, *, level=3): ...
>>> pv.register_writer('.myformat', my_writer) # doctest:+SKIP
>>> pv.Sphere().save('sphere.myformat', level=9) # doctest:+SKIP
Use as a decorator.
>>> @pv.register_writer('.myformat') # doctest:+SKIP
... def my_writer(dataset, path, **kwargs): ...
registered_writers() -> 'tuple[WriterRegistration, ...]'
Return every custom writer currently registered.
Forces discovery of any pending entry-point plugins so the returned
list reflects every writer visible to PyVista. A plugin that fails to
import emits a ``UserWarning`` and is skipped; the rest still appear
in the result.
.. versionadded:: 0.48.0
Returns
-------
tuple[WriterRegistration, ...]
One record per registered extension. Each record exposes
``extension``, ``handler``, and ``source``.
Examples
--------
>>> import pyvista as pv
>>> def my_writer(dataset, path, **kwargs): ...
>>> pv.register_writer('.demo_writer', my_writer)
>>> [
... r.extension
... for r in pv.registered_writers()
... if r.extension == '.demo_writer'
... ]
['.demo_writer']
DATA
TYPE_CHECKING = False
__annotations__ = {'_builtin_writer_exts': 'frozenset[str] | None', '_...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pyvista\core\utilities\writer_registry.py